【深度学习】（11）--迁移学习

🕗 发布于 2024-09-29 15:25 深度学习 迁移学习 人工智能 pytorch 卷积神经网络

文章目录

迁移学习
总结

迁移学习

迁移学习是指利用已经训练好的模型，在新的任务上进行微调。迁移学习可以加快模型训练速度，提高模型性能，并且在数据稀缺的情况下也能很好地工作。

一、迁移学习步骤

选择预训练的模型和适当的层：通常，我们会选择在大规模图像数据集（如ImageNet）上预训练的模型，如VGG、ResNet等。然后，根据新数据集的特点，选择需要微调的模型层。对于低级特征的任务（如边缘检测），最好使用浅层模型的层，而对于高级特征的任务（如分类），则应选择更深层次的模型。
冻结预训练模型的参数：保持预训练模型的权重不变，只训练新增加的层或者微调一些层，避免因为在数据集中过拟合导致预训练模型过度拟合。
在新数据集上训练新增加的层：在冻结预训练模型的参数情况下，训练新增加的层。这样，可以使新模型适应新的任务，从而获得更高的性能。
微调预训练模型的层：在新层上进行训练后，可以解冻一些已经训练过的层，并且将它们作为微调的目标。这样做可以提高模型在新数据集上的性能。
评估和测试：在训练完成之后，使用测试集对模型进行评估。如果模型的性能仍然不够好，可以尝试调整超参数或者更改微调层。

二、以残差网络为例

1. 导入模型

从torchvision中导入模型，库中已经存放好了大量模型框架。

import torchvision.models as models

resnet_model = models.resnet18(weights = models.ResNet18_Weights.DEFAULT)
# weights = models.ResNet18_Weights.DEFAULT表示在使用ImageNet数据集上预先训练好的权重来初始化模型参数

2. 冻结参数

冻结参数，使得在反向传播过程中，不要在计算他们的梯度，减少计算量。

for param in resnet_model.parameters():
    print(param)
    # 模型所有的参数（权重和偏置项）的requires_grad属性设置为False，冻结所有模型参数
    # 使得在反向传播过程中，不要在计算他们的梯度，减少计算量
    param.requires_grad = False

3. 修改全连接层

因为原本模型中的输出有1000种特征，而我们现在训练的数据仅有20种特征，需要需改输出：

# 获取模型原输入的特征个数
in_features = resnet_model.fc.in_features
# 创建一个全连接层（将原全连接层覆盖），输入特征为in_features，输出为20
resnet_model.fc = nn.Linear(in_features,20)

params_to_update = [] # 保存需要训练的参数，仅训练修改的全连接层参数
for param in resnet_model.parameters():
    if param.requires_grad == True:
        params_to_update.append(param)

4. 创建数据集的类

残差模型的传入数据大小为（224），所以要对数据进行裁剪

data_transforms = {
    'train':
        transforms.Compose([
            transforms.Resize([300,300]),
            transforms.RandomRotation(45), # 随机旋转，-45到45度之间随便选
            transforms.CenterCrop(224), # 从中心开始剪裁
            transforms.RandomHorizontalFlip(p=0.5),# 随机水平反转，设定一个概率
            transforms.RandomVerticalFlip(p=0.5),# 随机垂直反转
            transforms.ColorJitter(brightness=0.2,contrast=0.1,saturation=0.1,hue=0.1),# 参数1亮度，参数2对比度，参数3饱和度，参数4色相
            transforms.RandomGrayscale(p=0.1),# 转化为灰度图
            transforms.ToTensor(),
            transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225]) # 标准化：均值，标准差（统一的）
        ]),
    'valid':
        transforms.Compose([
            transforms.Resize([224,224]),
            transforms.ToTensor(),
            transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])
        ]),
}

5. 处理数据

划分数据中的特征与标签：

"""-----处理数据-----"""
class food_dataset(Dataset):
    def __init__(self,file_path,transform = None):
        self.file_path = file_path
        self.imgs = []
        self.labels = []
        self.transform = transform
        with open(self.file_path) as f:
            samples = [x.strip().split(' ') for x in f.readlines()]
            for img_path,label in samples:
                self.imgs.append(img_path) # 特征
                self.labels.append(label)# 标签

    def __len__(self):
        return len(self.imgs)
    def __getitem__(self, idx):
        image = Image.open(self.imgs[idx])
        if self.transform:
            image = self.transform(image)

        label = self.labels[idx]
        label = torch.from_numpy(np.array(label,dtype=np.int64))
        return image,label

training_data = food_dataset(file_path='trainda.txt',transform=data_transforms['train'])
test_data = food_dataset(file_path='testda.txt',transform=data_transforms['valid'])

train_dataloader = DataLoader(training_data,batch_size=64,shuffle=True)
test_dataloader = DataLoader(test_data,batch_size=64,shuffle=True)

6. 装配设备

"""---判断当前设备是否支持GPU，其中mps是苹果m系列芯片的GPU"""
device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"

7. 建立模型

"""-----建立模型-----"""
model = resnet_model.to(device)

8. 训练模型

"""-----训练集-----"""
def train(dataloader,model,loss_fn,optimizer):
    model.train()

    batch_size_num =1
    for x,y in dataloader:
        x,y = x.to(device),y.to(device)
        pred = model.forward(x)
        loss = loss_fn(pred,y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        loss_value = loss.item()  # 获取损失值
        if batch_size_num %20 == 0:  # 每200次迭代打印一次损失
            print(f"loss:{loss_value:>7f} [number:{batch_size_num}]")
        batch_size_num += 1

best_acc = 0
"""-----测试集-----"""
def test(dataloader,model,loss_fn):
    global best_acc
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    model.eval()
    test_loss,correct = 0,0
    with torch.no_grad():
        for x,y in dataloader:
            x,y = x.to(device),y.to(device)
            pred = model.forward(x)
            test_loss += loss_fn(pred,y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= num_batches
    correct /= size
    correct = round(correct, 4)
    print(f"Test result: \n Accuracy:{(100*correct)}%,Avg loss:{test_loss}")
    acc_s.append(correct)
    loss_s.append(test_loss)

    if correct > best_acc:
        best_acc = correct

"""-----损失函数-----"""
loss_fn = nn.CrossEntropyLoss()

"""-----优化器-----"""
optimizer = torch.optim.Adam(params_to_update,lr=0.001)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,step_size=5,gamma=0.5)

epochs = 100
acc_s = []
loss_s = []
for t in range(epochs):
    print(f"Epoch {t+1} \n-------------------------")
    train(train_dataloader,model,loss_fn,optimizer)
    scheduler.step()
    test(test_dataloader,model,loss_fn)
print('最优训练结果：',best_acc)

结果：

在这里插入图片描述

三、完整代码展示

import torch
import torchvision.models as models
from torch import nn
from torch.utils.data import Dataset,DataLoader
import numpy as np
from PIL import Image
from torchvision import transforms

"""将resnet18模型迁移到食物分类项目中"""#残差网络是固定的网络结构，不需要自己来类定义
resnet_model = models.resnet18(weights = models.ResNet18_Weights.DEFAULT)
# weights = models.ResNet18_Weights.DEFAULT表示在使用ImageNet数据集上预先训练好的权重来初始化模型参数
for param in resnet_model.parameters():
    print(param)
    # 模型所有的参数（权重和偏置项）的requires_grad属性设置为False，冻结所有模型参数
    # 使得在反向传播过程中，不要在计算他们的梯度，减少计算量
    param.requires_grad = False

"""-----修改残差模型中的全连接层-----"""# 因为原本模型中的输出有1000种特征，而我们现在训练的数据仅有20种特征，需要需改输出
# 获取模型原输入的特征个数
in_features = resnet_model.fc.in_features
# 创建一个全连接层（将原全连接层覆盖），输入特征为in_features，输出为20
resnet_model.fc = nn.Linear(in_features,20)

params_to_update = [] # 保存需要训练的参数，进训练修改的全连接层
for param in resnet_model.parameters():
    if param.requires_grad == True:
        params_to_update.append(param)

"""-----创建数据集的类-----"""# 残差模型的传入数据大小为（224），所以要对数据进行裁剪
data_transforms = {
    'train':
        transforms.Compose([
            transforms.Resize([300,300]),
            transforms.RandomRotation(45), # 随机旋转，-45到45度之间随便选
            transforms.CenterCrop(224), # 从中心开始剪裁
            transforms.RandomHorizontalFlip(p=0.5),# 随机水平反转，设定一个概率
            transforms.RandomVerticalFlip(p=0.5),# 随机垂直反转
            transforms.ColorJitter(brightness=0.2,contrast=0.1,saturation=0.1,hue=0.1),# 参数1亮度，参数2对比度，参数3饱和度，参数4色相
            transforms.RandomGrayscale(p=0.1),# 转化为灰度图
            transforms.ToTensor(),
            transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225]) # 标准化：均值，标准差（统一的）
        ]),
    'valid':
        transforms.Compose([
            transforms.Resize([224,224]),
            transforms.ToTensor(),
            transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])
        ]),
}

"""-----处理数据-----"""
class food_dataset(Dataset):
    def __init__(self,file_path,transform = None):
        self.file_path = file_path
        self.imgs = []
        self.labels = []
        self.transform = transform
        with open(self.file_path) as f:
            samples = [x.strip().split(' ') for x in f.readlines()]
            for img_path,label in samples:
                self.imgs.append(img_path)
                self.labels.append(label)

    def __len__(self):
        return len(self.imgs)
    def __getitem__(self, idx):
        image = Image.open(self.imgs[idx])
        if self.transform:
            image = self.transform(image)

        label = self.labels[idx]
        label = torch.from_numpy(np.array(label,dtype=np.int64))
        return image,label

"""---判断当前设备是否支持GPU，其中mps是苹果m系列芯片的GPU"""
device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
print(f"Using {device} device")

"""-----数据处理-----"""
training_data = food_dataset(file_path='trainda.txt',transform=data_transforms['train'])
test_data = food_dataset(file_path='testda.txt',transform=data_transforms['valid'])

train_dataloader = DataLoader(training_data,batch_size=64,shuffle=True)
test_dataloader = DataLoader(test_data,batch_size=64,shuffle=True)

"""-----建立模型-----"""
model = resnet_model.to(device)

"""-----损失函数-----"""
loss_fn = nn.CrossEntropyLoss()

"""-----优化器-----"""
optimizer = torch.optim.Adam(params_to_update,lr=0.001)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,step_size=5,gamma=0.5)

"""-----训练集-----"""
def train(dataloader,model,loss_fn,optimizer):
    model.train()

    batch_size_num =1
    for x,y in dataloader:
        x,y = x.to(device),y.to(device)
        pred = model.forward(x)
        loss = loss_fn(pred,y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        loss_value = loss.item()  # 获取损失值
        if batch_size_num %20 == 0:  # 每200次迭代打印一次损失
            print(f"loss:{loss_value:>7f} [number:{batch_size_num}]")
        batch_size_num += 1

best_acc = 0
"""-----测试集-----"""
def test(dataloader,model,loss_fn):
    global best_acc
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    model.eval()
    test_loss,correct = 0,0
    with torch.no_grad():
        for x,y in dataloader:
            x,y = x.to(device),y.to(device)
            pred = model.forward(x)
            test_loss += loss_fn(pred,y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= num_batches
    correct /= size
    correct = round(correct, 4)
    print(f"Test result: \n Accuracy:{(100*correct)}%,Avg loss:{test_loss}")
    acc_s.append(correct)
    loss_s.append(test_loss)

    if correct > best_acc:
        best_acc = correct

"""-----训练模型-----"""
epochs = 100
acc_s = []
loss_s = []
for t in range(epochs):
    print(f"Epoch {t+1} \n-------------------------")
    train(train_dataloader,model,loss_fn,optimizer)
    scheduler.step()
    test(test_dataloader,model,loss_fn)
print('最优训练结果：',best_acc)

总结

本篇介绍了：

如何进行迁移学习
对迁移模型进行微调：
1. 微调全连接层
2. 微调卷积层（本篇未写），原理相同，可自行尝试
注意：原本的模型参数务必要冻结住，那是已经调好的，可以节省计算时间。仅需要调整修改部分的参数。

原文地址：https://blog.csdn.net/m0_74896766/article/details/142628872

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：JavaScript高级——事件循环模型
下一篇：Flink CDC

MySQL数据库基础
在过去的mysql中主要是使用的utf8mb3，但是mysql显示的就是utf8，中mysql8中区分显示了。类似于不同的编译器，虽然C/C++的代码是一样的，但是预处理、编译、汇编、链接这些过程却不
阅读更多2024-09-30
Percona Monitoring and Management
Percona Monitoring and Management (PMM)是一款开源的专用于管理和监控MySQL、MongoDB、PostgreSQL。
阅读更多2024-09-30
鸿蒙开发（NEXT/API 12）【已连接穿戴设备查询】手机侧应用开发
Wear Engine提供查询用户已连接的穿戴设备列表（即支持Wear Engine能力且与手机侧运动健康App处于连接状态的穿戴设备）的接口。
阅读更多2024-09-30
Redis数据库
本篇文章介绍了redis的相关知识，并使用springboot集成redis，实现缓存和分布式锁，后续会对文章勘误及更新~~
阅读更多2024-09-30
旧版的存档
【代码】旧版的存档。
阅读更多2024-09-30
Spring Boot 封装统一返回结果及全局异常处理
为了更细致地控制异常处理，我们可以定义一些自定义异常。然后，在全局异常处理器中添加对自定义异常的处理。通过封装统一的返回结果和全局异常处理，我们可以让Spring Boot应用更加健壮和易于维护。这种
阅读更多2024-09-30
【C++】IO流
C++IO流，包含输入输出流、文件流、字符流
阅读更多2024-09-30
低至1元/小时：国庆七天，30元通关《黑神话：悟空》！
随着《黑神话：悟空》自8月20日全球同步上线，正式登陆PC、PS5平台以来，以其精湛的画面和流畅的战斗体验，在发售三天后，该作的全平台销量超过1000万套，打破中国游戏历史记录，被媒体称为“中国首款3
阅读更多2024-09-30
阿里巴巴国际站获取商品详情item_get接口技术分享
item_get API接口是阿里巴巴开放平台提供的一个重要接口，它允许商家通过API调用，获取阿里巴巴平台上的商品详细信息。这些信息包括商品标题、价格、库存、属性、描述等，为商家提供了全面、准确的商
阅读更多2024-09-30
软件测试谣言二三事，认真你就输了
软件测试的职业寿命，取决于互联网行业能存活多久，至少目前看来，这个职业没有消失的风险，至于你能在这个职业待多久，那取决于你自己的能力，我见过不少超过35岁的老员工还在测试的职位上兢兢业业。以广州为例，
阅读更多2024-09-30