模型加载与保存 和 迁移学习

最新推荐文章于 2024-03-17 22:31:55 发布
最新推荐文章于 2024-03-17 22:31:55 发布
阅读量528 收藏 1
点赞数
分类专栏： Pytorch框架教程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuxiao789/article/details/109002574
版权 
# -*- coding: utf-8 -*-
"""
# @file name  : model_save.py
# @author     : TingsongYu https://github.com/TingsongYu
# @date       : 2019-11-04
# @brief      : 模型的保存
"""
import torch
import numpy as np
import torch.nn as nn
from tools.common_tools import set_seed


class LeNet2(nn.Module):
    def __init__(self, classes):
        super(LeNet2, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 6, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),
            nn.Conv2d(6, 16, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )
        self.classifier = nn.Sequential(
            nn.Linear(16*5*5, 120),
            nn.ReLU(),
            nn.Linear(120, 84),
            nn.ReLU(),
            nn.Linear(84, classes)
        )

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size()[0], -1)
        x = self.classifier(x)
        return x

    def initialize(self):
        for p in self.parameters():
            p.data.fill_(20191104)


net = LeNet2(classes=2019)

# "训练"
print("训练前: ", net.features[0].weight[0, ...])
net.initialize()
print("训练后: ", net.features[0].weight[0, ...])

path_model = "./model.pkl"
path_state_dict = "./model_state_dict.pkl"

# 【1】保存整个模型
torch.save(net, path_model)

# 【2】保存模型参数
net_state_dict = net.state_dict()
torch.save(net_state_dict, path_state_dict)


'''
训练前:  tensor([[[-0.0171, -0.0240,  0.0583, -0.0436, -0.1023],
         [-0.0040,  0.0459,  0.0329,  0.0238, -0.0684],
         [ 0.0143,  0.0227, -0.0958,  0.1137, -0.0172],
         [ 0.0472, -0.0560, -0.0124, -0.0546,  0.0028],
         [-0.1014,  0.0038, -0.0114, -0.0888,  0.0502]],

        [[ 0.0923, -0.1140,  0.0024,  0.1067,  0.0145],
         [ 0.0066,  0.1078,  0.0062, -0.0608, -0.0921],
         [ 0.0756, -0.0555, -0.0662,  0.0693, -0.0672],
         [ 0.0789,  0.1093, -0.1038,  0.0564, -0.0815],
         [ 0.0309,  0.0716,  0.0900,  0.0632, -0.0634]],

        [[-0.0427,  0.1043,  0.0825,  0.0391, -0.1001],
         [-0.0736, -0.0121, -0.0024, -0.0023,  0.0294],
         [-0.0045,  0.0147, -0.0603, -0.0179,  0.0630],
         [ 0.0737, -0.1111, -0.0918, -0.1032, -0.0464],
         [ 0.0810,  0.0424,  0.0439,  0.0495, -0.0879]]],
       grad_fn=<SelectBackward>)
训练后:  tensor([[[20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.]],

        [[20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.]],

        [[20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.]]],
       grad_fn=<SelectBackward>)
'''









import torch
import numpy as np
import torch.nn as nn
from tools.common_tools import set_seed


class LeNet2(nn.Module):
    def __init__(self, classes):
        super(LeNet2, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 6, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),
            nn.Conv2d(6, 16, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )
        self.classifier = nn.Sequential(
            nn.Linear(16*5*5, 120),
            nn.ReLU(),
            nn.Linear(120, 84),
            nn.ReLU(),
            nn.Linear(84, classes)
        )

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size()[0], -1)
        x = self.classifier(x)
        return x

    def initialize(self):
        for p in self.parameters():
            p.data.fill_(20191104)


# ================================== load net ===========================
# flag = 1
flag = 0
if flag:

    path_model = "./model.pkl"
    net_load = torch.load(path_model)

    print(net_load)

# ================================== load state_dict ===========================

flag = 1
# flag = 0
if flag:

    path_state_dict = "./model_state_dict.pkl"
    state_dict_load = torch.load(path_state_dict)

    print(state_dict_load.keys())
# 这些参数字典加载后，需要放在 模型中

# ================================== update state_dict ===========================
flag = 1
# flag = 0
if flag:

    net_new = LeNet2(classes=2019)

    print("加载前: ", net_new.features[0].weight[0, ...])

    # 通过函数.load_state_dict(state_dict_load 加载的参数)
    net_new.load_state_dict(state_dict_load)
    print("加载后: ", net_new.features[0].weight[0, ...])



'''
LeNet2(
  (features): Sequential(
    (0): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
    (4): ReLU()
    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (classifier): Sequential(
    (0): Linear(in_features=400, out_features=120, bias=True)
    (1): ReLU()
    (2): Linear(in_features=120, out_features=84, bias=True)
    (3): ReLU()
    (4): Linear(in_features=84, out_features=2019, bias=True)
  )
)

odict_keys(['features.0.weight'：第一个卷积层权重, 'features.0.bias'：第一个卷积层的偏置, 'features.3.weight'：第二个卷积层权重, 'features.3.bias', 'classifier.0.weight', 'classifier.0.bias', 'classifier.2.weight', 'classifier.2.bias', 'classifier.4.weight', 'classifier.4.bias'])
加载前:  tensor([[[-2.9204e-02,  1.0396e-01, -7.6845e-02,  1.0860e-01,  4.8083e-03],
         [-1.1324e-01,  8.3432e-03,  1.0644e-01, -5.2714e-02, -4.8218e-02],
         [ 5.3088e-02,  8.8120e-02,  1.7474e-02,  4.1145e-02, -8.8373e-02],
         [-4.3376e-02,  4.2345e-02,  3.7227e-02,  6.7585e-02,  1.2905e-02],
         [-8.6850e-03,  6.4530e-02, -5.5927e-03, -4.2035e-02, -7.1110e-02]],

        [[ 2.0341e-02,  7.2431e-02,  4.9812e-02, -1.1150e-01, -7.2757e-02],
         [ 1.0115e-01, -1.0875e-01,  7.3108e-02, -1.0423e-01, -9.5344e-03],
         [-1.1853e-02, -7.3327e-02, -6.8280e-02, -4.3455e-02,  8.4874e-02],
         [ 8.3891e-02,  5.1581e-03, -4.5754e-03, -6.3173e-02,  5.2947e-02],
         [-3.1440e-02, -2.1541e-02,  5.9413e-02,  3.1071e-02,  1.0378e-02]],

        [[ 7.4961e-03, -8.7507e-03, -5.9233e-04,  4.7734e-02,  2.3177e-02],
         [ 2.4812e-02, -4.5111e-03,  2.0181e-02,  9.6714e-02,  1.8875e-02],
         [-4.5268e-02,  8.1030e-02,  1.0445e-04, -7.6447e-02,  6.7227e-02],
         [-4.6416e-02,  6.2644e-02,  8.5726e-02, -4.2743e-02,  9.9050e-02],
         [ 1.6748e-02, -1.8100e-02,  2.0550e-03,  8.3281e-03, -8.2732e-02]]],
       grad_fn=<SelectBackward>)
加载后:  tensor([[[20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.]],

        [[20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.]],

        [[20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.],
         [20191104., 20191104., 20191104., 20191104., 20191104.]]],
       grad_fn=<SelectBackward>)
'''



import os
import random
import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.optim as optim
from PIL import Image
from matplotlib import pyplot as plt
from model.lenet import LeNet
from tools.my_dataset import RMBDataset
from tools.common_tools import set_seed
import torchvision


set_seed(1)  # 设置随机种子
rmb_label = {"1": 0, "100": 1}

# 【1】参数设置，每隔5个epoch就保存一次
checkpoint_interval = 5
MAX_EPOCH = 10
BATCH_SIZE = 16
LR = 0.01
log_interval = 10
val_interval = 1


# ============================ step 1/5 数据 ============================

split_dir = os.path.join("..", "..", "data", "rmb_split")
train_dir = os.path.join(split_dir, "train")
valid_dir = os.path.join(split_dir, "valid")

norm_mean = [0.485, 0.456, 0.406]
norm_std = [0.229, 0.224, 0.225]

train_transform = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.RandomCrop(32, padding=4),
    transforms.RandomGrayscale(p=0.8),
    transforms.ToTensor(),
    transforms.Normalize(norm_mean, norm_std),
])

valid_transform = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.ToTensor(),
    transforms.Normalize(norm_mean, norm_std),
])

# 构建MyDataset实例
train_data = RMBDataset(data_dir=train_dir, transform=train_transform)
valid_data = RMBDataset(data_dir=valid_dir, transform=valid_transform)

# 构建DataLoder
train_loader = DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
valid_loader = DataLoader(dataset=valid_data, batch_size=BATCH_SIZE)

# ============================ step 2/5 模型 ============================

net = LeNet(classes=2)
net.initialize_weights()

# ============================ step 3/5 损失函数 ============================
criterion = nn.CrossEntropyLoss()                                                   # 选择损失函数

# ============================ step 4/5 优化器 ============================
optimizer = optim.SGD(net.parameters(), lr=LR, momentum=0.9)                        # 选择优化器
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=6, gamma=0.1)     # 设置学习率下降策略

# ============================ step 5/5 训练 ============================
train_curve = list()
valid_curve = list()

start_epoch = -1
for epoch in range(start_epoch+1, MAX_EPOCH):

    loss_mean = 0.
    correct = 0.
    total = 0.

    net.train()
    for i, data in enumerate(train_loader):

        # forward
        inputs, labels = data
        outputs = net(inputs)

        # backward
        optimizer.zero_grad()
        loss = criterion(outputs, labels)
        loss.backward()

        # update weights
        optimizer.step()

        # 统计分类情况
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).squeeze().sum().numpy()

        # 打印训练信息
        loss_mean += loss.item()
        train_curve.append(loss.item())
        if (i+1) % log_interval == 0:
            loss_mean = loss_mean / log_interval
            print("Training:Epoch[{:0>3}/{:0>3}] Iteration[{:0>3}/{:0>3}] Loss: {:.4f} Acc:{:.2%}".format(
                epoch, MAX_EPOCH, i+1, len(train_loader), loss_mean, correct / total))
            loss_mean = 0.

    scheduler.step()  # 更新学习率

    # 【2】保存断点
    if (epoch+1) % checkpoint_interval == 0:

        # 构建checkpoint
        checkpoint = {"model_state_dict": net.state_dict(),
                      "optimizer_state_dict": optimizer.state_dict(),
                      "epoch": epoch}
        path_checkpoint = "./checkpoint_{}_epoch.pkl".format(epoch)
        torch.save(checkpoint, path_checkpoint)

    if epoch > 5:
        print("训练意外中断...")
        break

    # validate the model
    if (epoch+1) % val_interval == 0:

        correct_val = 0.
        total_val = 0.
        loss_val = 0.
        net.eval()
        with torch.no_grad():
            for j, data in enumerate(valid_loader):
                inputs, labels = data
                outputs = net(inputs)
                loss = criterion(outputs, labels)

                _, predicted = torch.max(outputs.data, 1)
                total_val += labels.size(0)
                correct_val += (predicted == labels).squeeze().sum().numpy()

                loss_val += loss.item()

            valid_curve.append(loss.item())
            print("Valid:\t Epoch[{:0>3}/{:0>3}] Iteration[{:0>3}/{:0>3}] Loss: {:.4f} Acc:{:.2%}".format(
                epoch, MAX_EPOCH, j+1, len(valid_loader), loss_val/len(valid_loader), correct / total))


train_x = range(len(train_curve))
train_y = train_curve

train_iters = len(train_loader)
valid_x = np.arange(1, len(valid_curve)+1) * train_iters*val_interval # 由于valid中记录的是epochloss，需要对记录点进行转换到iterations
valid_y = valid_curve

plt.plot(train_x, train_y, label='Train')
plt.plot(valid_x, valid_y, label='Valid')

plt.legend(loc='upper right')
plt.ylabel('loss value')
plt.xlabel('Iteration')
plt.show()



import os
import random
import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.optim as optim
from PIL import Image
from matplotlib import pyplot as plt
from model.lenet import LeNet
from tools.my_dataset import RMBDataset
from tools.common_tools import set_seed
import torchvision


set_seed(1)  # 设置随机种子
rmb_label = {"1": 0, "100": 1}

# 参数设置
checkpoint_interval = 5
MAX_EPOCH = 10
BATCH_SIZE = 16
LR = 0.01
log_interval = 10
val_interval = 1


# ============================ step 1/5 数据 ============================

split_dir = os.path.join("..", "..", "data", "rmb_split")
train_dir = os.path.join(split_dir, "train")
valid_dir = os.path.join(split_dir, "valid")

norm_mean = [0.485, 0.456, 0.406]
norm_std = [0.229, 0.224, 0.225]

train_transform = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.RandomCrop(32, padding=4),
    transforms.RandomGrayscale(p=0.8),
    transforms.ToTensor(),
    transforms.Normalize(norm_mean, norm_std),
])

valid_transform = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.ToTensor(),
    transforms.Normalize(norm_mean, norm_std),
])

# 构建MyDataset实例
train_data = RMBDataset(data_dir=train_dir, transform=train_transform)
valid_data = RMBDataset(data_dir=valid_dir, transform=valid_transform)

# 构建DataLoder
train_loader = DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
valid_loader = DataLoader(dataset=valid_data, batch_size=BATCH_SIZE)

# ============================ step 2/5 模型 ============================

net = LeNet(classes=2)
net.initialize_weights()

# ============================ step 3/5 损失函数 ============================
criterion = nn.CrossEntropyLoss()                                                   # 选择损失函数

# ============================ step 4/5 优化器 ============================
optimizer = optim.SGD(net.parameters(), lr=LR, momentum=0.9)                        # 选择优化器
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=6, gamma=0.1)     # 设置学习率下降策略


# ============================ step 5+/5 断点恢复 ============================

# 【1】加载checkpoint
path_checkpoint = "./checkpoint_4_epoch.pkl"
checkpoint = torch.load(path_checkpoint)

# 模型数据更新
net.load_state_dict(checkpoint['model_state_dict'])

# 优化器数据更新
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])

# 起始的epoch
start_epoch = checkpoint['epoch']

# 更改学习率
scheduler.last_epoch = start_epoch

# ============================ step 5/5 训练 ============================
train_curve = list()
valid_curve = list()

for epoch in range(start_epoch + 1, MAX_EPOCH):

    loss_mean = 0.
    correct = 0.
    total = 0.

    net.train()
    for i, data in enumerate(train_loader):

        # forward
        inputs, labels = data
        outputs = net(inputs)

        # backward
        optimizer.zero_grad()
        loss = criterion(outputs, labels)
        loss.backward()

        # update weights
        optimizer.step()

        # 统计分类情况
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).squeeze().sum().numpy()

        # 打印训练信息
        loss_mean += loss.item()
        train_curve.append(loss.item())
        if (i+1) % log_interval == 0:
            loss_mean = loss_mean / log_interval
            print("Training:Epoch[{:0>3}/{:0>3}] Iteration[{:0>3}/{:0>3}] Loss: {:.4f} Acc:{:.2%}".format(
                epoch, MAX_EPOCH, i+1, len(train_loader), loss_mean, correct / total))
            loss_mean = 0.

    scheduler.step()  # 更新学习率

#
    if (epoch+1) % checkpoint_interval == 0:

        checkpoint = {"model_state_dict": net.state_dict(),
                      "optimizer_state_dic": optimizer.state_dict(),
                      "loss": loss,
                      "epoch": epoch}
        path_checkpoint = "./checkpint_{}_epoch.pkl".format(epoch)
        torch.save(checkpoint, path_checkpoint)

    # if epoch > 5:
    #     print("训练意外中断...")
    #     break

    # validate the model
    if (epoch+1) % val_interval == 0:

        correct_val = 0.
        total_val = 0.
        loss_val = 0.
        net.eval()
        with torch.no_grad():
            for j, data in enumerate(valid_loader):
                inputs, labels = data
                outputs = net(inputs)
                loss = criterion(outputs, labels)

                _, predicted = torch.max(outputs.data, 1)
                total_val += labels.size(0)
                correct_val += (predicted == labels).squeeze().sum().numpy()

                loss_val += loss.item()

            valid_curve.append(loss.item())
            print("Valid:\t Epoch[{:0>3}/{:0>3}] Iteration[{:0>3}/{:0>3}] Loss: {:.4f} Acc:{:.2%}".format(
                epoch, MAX_EPOCH, j+1, len(valid_loader), loss_val/len(valid_loader), correct / total))


train_x = range(len(train_curve))
train_y = train_curve

train_iters = len(train_loader)
valid_x = np.arange(1, len(valid_curve)+1) * train_iters*val_interval # 由于valid中记录的是epochloss，需要对记录点进行转换到iterations
valid_y = valid_curve

plt.plot(train_x, train_y, label='Train')
plt.plot(valid_x, valid_y, label='Valid')

plt.legend(loc='upper right')
plt.ylabel('loss value')
plt.xlabel('Iteration')
plt.show()



import os
import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.optim as optim
from matplotlib import pyplot as plt
from tools.my_dataset import AntsDataset
from tools.common_tools import set_seed
import torchvision.models as models
import torchvision
BASEDIR = os.path.dirname(os.path.abspath(__file__))
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("use device :{}".format(device))

set_seed(1)  # 设置随机种子
label_name = {"ants": 0, "bees": 1}

# 参数设置
MAX_EPOCH = 25
BATCH_SIZE = 16
LR = 0.001
log_interval = 10
val_interval = 1
classes = 2
start_epoch = -1
lr_decay_step = 7


# ============================ step 1/5 数据 ============================
data_dir = os.path.join(BASEDIR, "..", "..", "data/hymenoptera_data")
train_dir = os.path.join(data_dir, "train")
valid_dir = os.path.join(data_dir, "val")

norm_mean = [0.485, 0.456, 0.406]
norm_std = [0.229, 0.224, 0.225]

train_transform = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(norm_mean, norm_std),
])

valid_transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(norm_mean, norm_std),
])

# 构建MyDataset实例
train_data = AntsDataset(data_dir=train_dir, transform=train_transform)
valid_data = AntsDataset(data_dir=valid_dir, transform=valid_transform)

# 构建DataLoder
train_loader = DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
valid_loader = DataLoader(dataset=valid_data, batch_size=BATCH_SIZE)

# ============================ step 2/5 模型 ============================

# 1/3 构建模型
resnet18_ft = models.resnet18()

# 2/3 加载参数
# flag = 0
flag = 1
if flag:
    path_pretrained_model = os.path.join(BASEDIR,"resnet18-5c106cde.pth")
    state_dict_load = torch.load(path_pretrained_model)
    resnet18_ft.load_state_dict(state_dict_load)

'''
# 【2.1】法1 : 冻结卷积层---》卷积核参数不会改变（数据量小的时候）
flag_m1 = 0
# flag_m1 = 1
if flag_m1:
    # 对模型的所有参数循环--》把这些参数的requires_grad = False（不再求梯度，则不会再更新）
    for param in resnet18_ft.parameters():
        param.requires_grad = False
    print("conv1.weights[0, 0, ...]:\n {}".format(resnet18_ft.conv1.weight[0, 0, ...]))
    # 第一个卷积层的卷积核参数
'''

# 3/3 替换fc层
# 【一】改变fc层适应新任务(num_ftrs：输入神经元个数, classes：输出个数)
num_ftrs = resnet18_ft.fc.in_features
resnet18_ft.fc = nn.Linear(num_ftrs, classes)


resnet18_ft.to(device)
# ============================ step 3/5 损失函数 ============================
criterion = nn.CrossEntropyLoss()                                                   # 选择损失函数

# ============================ step 4/5 优化器 ============================
# 【2.2】法2 : conv 小学习率
# 优化器可以管理不同的参数组，为不同的参数组设置不同的超参数---》这样可以把卷积核的部分认为是一个参数组，全连接部分是
# 另外一个参数组----》从而实现不同的参数设置不同的学习率
# flag = 0
flag = 1
if flag:
    fc_params_id = list(map(id, resnet18_ft.fc.parameters()))     # 返回的是模型的全连接层parameters的 内存地址

    # 是把resnet18的所有参数，过滤掉fc层---》当前参数id(p)不属于fc内存地址fc_params_id--》保留下来
    # 得到的是前面这些卷积层的参数
    base_params = filter(lambda p: id(p) not in fc_params_id, resnet18_ft.parameters())

    #
    optimizer = optim.SGD([
        {'params': base_params, 'lr': LR*0},   # 0
        {'params': resnet18_ft.fc.parameters(), 'lr': LR}], momentum=0.9)

else:
    optimizer = optim.SGD(resnet18_ft.parameters(), lr=LR, momentum=0.9)               # 选择优化器

scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=lr_decay_step, gamma=0.1)     # 设置学习率下降策略


# ============================ step 5/5 训练 ============================
train_curve = list()
valid_curve = list()

for epoch in range(start_epoch + 1, MAX_EPOCH):

    loss_mean = 0.
    correct = 0.
    total = 0.

    resnet18_ft.train()
    for i, data in enumerate(train_loader):

        # forward
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)
        outputs = resnet18_ft(inputs)

        # backward
        optimizer.zero_grad()
        loss = criterion(outputs, labels)
        loss.backward()

        # update weights
        optimizer.step()

        # 统计分类情况
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).squeeze().cpu().sum().numpy()

        # 打印训练信息
        loss_mean += loss.item()
        train_curve.append(loss.item())
        if (i+1) % log_interval == 0:
            loss_mean = loss_mean / log_interval
            print("Training:Epoch[{:0>3}/{:0>3}] Iteration[{:0>3}/{:0>3}] Loss: {:.4f} Acc:{:.2%}".format(
                epoch, MAX_EPOCH, i+1, len(train_loader), loss_mean, correct / total))
            loss_mean = 0.

            # if flag_m1:
            print("epoch:{} conv1.weights[0, 0, ...] :\n {}".format(epoch, resnet18_ft.conv1.weight[0, 0, ...]))

    scheduler.step()  # 更新学习率

    # validate the model
    if (epoch+1) % val_interval == 0:

        correct_val = 0.
        total_val = 0.
        loss_val = 0.
        resnet18_ft.eval()
        with torch.no_grad():
            for j, data in enumerate(valid_loader):
                inputs, labels = data
                inputs, labels = inputs.to(device), labels.to(device)

                outputs = resnet18_ft(inputs)
                loss = criterion(outputs, labels)

                _, predicted = torch.max(outputs.data, 1)
                total_val += labels.size(0)
                correct_val += (predicted == labels).squeeze().cpu().sum().numpy()

                loss_val += loss.item()

            loss_val_mean = loss_val/len(valid_loader)
            valid_curve.append(loss_val_mean)
            print("Valid:\t Epoch[{:0>3}/{:0>3}] Iteration[{:0>3}/{:0>3}] Loss: {:.4f} Acc:{:.2%}".format(
                epoch, MAX_EPOCH, j+1, len(valid_loader), loss_val_mean, correct_val / total_val))
        resnet18_ft.train()

train_x = range(len(train_curve))
train_y = train_curve

train_iters = len(train_loader)
valid_x = np.arange(1, len(valid_curve)+1) * train_iters*val_interval # 由于valid中记录的是epochloss，需要对记录点进行转换到iterations
valid_y = valid_curve

plt.plot(train_x, train_y, label='Train')
plt.plot(valid_x, valid_y, label='Valid')

plt.legend(loc='upper right')
plt.ylabel('loss value')
plt.xlabel('Iteration')
plt.show()

 

liuxiao789
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pytorch 16 迁移学习核心技巧·从模型加载到按需初始化模块权重，再到各layer分组设置学习率
a486259的博客
01-12 714
实现加载模型任意权重，自动跳过不匹配的layer（name不匹配，权重shape不匹配），该操作通常用在迁移学习模型加载中。 实现对模型中不同moudle甚至不同name的layer进行不同方式的初始化，该操作通常用在迁移学习模型初始化中。 实现对模型中不同的部分设置不同的学习率（支持冻结某些layer），该操作通常用在迁移学习模型训练阶段中。
IMDb Dataset-迁移学习
03-23
在create_data.py文件中，已经使用GLOVE Embeddings加载并保存了单词索引; -接下来的步骤是使用这些预先训练的词嵌入，以便在lstm_training.py文件中建立一个双向LSTM。 2. -在文件word_index_create.py中，相反，它...
迁移学习-模型参数加载
小幸运
03-10 732
1. 模型定义时name规则 定义了变量名的，name=变量名； 没有定义变量名的，使用Sequential()的，从0开始标号name。 class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1=nn.Conv2d(in_channels=3,ou...
迁移学习--网络模型的保存和读取
m0_59199033的博客
05-10 637
迁移学习--网络模型的保存和读取
迁移学习-加载预训练模型-图像分类案例（模型冻结，解冻等练习）
qq_43647582的博客
03-17 877
【代码】【无标题】
Keras学习之：全网最详细，一文包你会！使用 Keras 自带的模型实现迁移学习
qq_42902997的博客
09-07 5450
文章目录迁移学习是什么，为什么要用迁移学习场景一场景二破局之法：迁移学习迁移学习主要的三种手段Keras 可以使用哪些已经训练好的模型模型选择：Inceptionv3实现步骤导入模块加载数据集调整数据集中图片的尺寸数据增强 / 使用简单的原始数据加载 Keras 中的 Inceptionv3 模型模型删改知识迁移第一种手段：Transfer Learning第三种手段：Fine-tune冻结之后的训练第二种手段 迁移学习是什么，为什么要用迁移学习 场景一 我们在训练模型的时候，拿 CNN 网络来举例，CNN
【Pytorch Lighting】第 3 章：使用预训练模型进行迁移学习
sikh_0529的博客
11-05 1917
您可能需要进行完整的培训选择。我们将使用一种流行的称为 ResNet-50 的 CNN 架构来构建我们的图像分类器，然后使用另一种称为 BERT 的重磅变压器架构来构建一个文本分类器。迁移学习是一种帮助我们利用从先前构建的模型中获得的知识的技术，该模型是为与我们的任务类似的任务而设计的。在进行迁移学习时，重要的是冻结现有层的权重以避免反向传播和重新训练，因为我们将利用现有的训练模型。准备数据的过程可能涉及加载数据、拆分数据、转换、特征工程和许多其他活动，以提供更好的结果，更重要的是，被模型接受。
keras使用迁移学习实现医学图像二分类
08-31
要解决的是一个医学图像的二分类问题，有AK和SK两种病症，根据一...keras中数据增强、回调函数的使用，回调函数涉及：学习速率调整、保存最好模型、tensorboard可视化 如何使用sklearn计算准确率，精确率，召回率，F1_
人工智能-项目实践-迁移学习-pytorch版-使用resnet50迁移学习实现皮肤病图片的二分类.zip
12-15
pytorch版—使用resnet50迁移学习实现皮肤病图片的二分类 代码目录介绍 args.py 存放训练和测试所用的各种参数。 --mode字段表示运行模式：train or test. --model_path字段是训练模型的保存路径。 其余字段都有...
基于pytorch使用resnet50迁移学习实现皮肤病图片的二分类源码+数据集+项目说明.zip
最新发布
05-21
data_gen.py 该脚本实现划分数据集以及数据增强和数据加载。 main.py 包含训练、评估和测试。 transform.py 实现图片增强。 utils.py 存放一些工具函数。 models/Res.py 是重写的ResNet各种类型的网络。 checkpoints...
基于VGG的图像风格迁移算法实现
04-13
使用优化器对生成的图片进行优化，使其在内容和风格上与输入的内容图片和风格图片相匹配。 在优化过程中，对生成的图片进行迭代更新，直到达到指定的迭代次数。 最终，生成的图片保存在指定的路径下，作为模型的输出...
Anaconda安装命令
liuxiao789的博客
10-21 1451
创建anaconda虚拟环境，一个项目对应一个虚拟环境。其中base是真实的环境。 1、Anaconda 安装成功。 接下来需要设置 Anaconda 仓库镜像，因为默认连接的是国外镜像地址，下载速度比较慢， 我们把镜像地址改为清华大学开源软件镜像站，Anaconda Prompt 窗口输入： conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/ conda config --set sho
3、DataSet 与 DataLoader
liuxiao789的博客
09-16 574
# -*- coding: utf-8 -*- """ # @file name : train_lenet.py # @author : tingsongyu # @date : 2019-09-07 10:08:00 # @brief : 人民币分类模型训练 """ import os import random import numpy as np import torch import torch.nn as nn from torch.utils.data imp.
3.3 卷积层实现
liuxiao789的博客
10-13 571
import os import torch.nn as nn from PIL import Image from torchvision import transforms from matplotlib import pyplot as plt from tools.common_tools import transform_invert, set_seed set_seed(2) # 设置随机种子---》权值初始化1,2，3 ''' eg: 3个不同的卷积核权值：不同的特征检测器--》出现3个.
2-1 transform1--数据增强
liuxiao789的博客
10-21 556
import os import numpy as np import torch import random from torch.utils.data import DataLoader import torchvision.transforms as transforms from tools.my_dataset import RMBDataset from PIL import Image from matplotlib import pyplot as plt def set_seed(s.
GPU的使用
liuxiao789的博客
10-10 489
# -*- coding: utf-8 -*- """ # @file name : cuda_methods.py # @author : TingsongYu https://github.com/TingsongYu # @date : 2019-11-11 # @brief : 数据迁移至cuda的方法 """ import torch import torch.nn as nn device = torch.device("cuda:0" if torch.cud.
PyTorch最基本的模型框架
liuxiao789的博客
04-27 347
import torch import torch.nn as nn import matplotlib.pyplot as plt import numpy as np torch.manual_seed(10) # ============================ step 1/5 生成数据 ============================ sample_nums = 100 mean_value = 1.7 bias = 1 n_data = torch.ones(sample_.
3.1模型创建步骤与nn.Module
liuxiao789的博客
10-12 340
import os import random import numpy as np import torch import torch.nn as nn from torch.utils.data import DataLoader import torchvision.transforms as transforms import torch.optim as optim from matplotlib import pyplot as plt from model.lenet import LeNe.
使用python基于迁移学习训练一个模型
09-25
可以根据需要设置训练的批次大小、迭代次数和学习率等参数。 7. 进行模型评估和预测。使用测试集对训练好的模型进行评估，计算模型的准确率、损失值等指标。然后，使用模型进行预测，得出对新样本的分类结果。 8. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值