pytorch实战5——DataLoader数据集制作

本文详细介绍了如何在PyTorch中自定义数据集,包括读取txt文件中的图像路径和标签,构建数据列表,整合到`FlowerDataset`类中,定义数据预处理变换,实例化dataloader,并进行数据验证。接着,文章提到了构建损失函数和优化器以及训练模型的函数,展示了一个完整的训练过程。
摘要由CSDN通过智能技术生成

目录

1.如何自定义数据集:

咱们以花朵数据集为例:

任务1:读取txt文件中的路径和标签

任务2:通过上面字典返回数据,分别把数据和标签都存在list里

任务3:图像数据路径得完整

任务4:把上面那几个事得写在一起,整合到一个类。

任务5:数据预处理(transform)¶

任务6:根据写好的class FlowerDataset(Dataset):来实例化咱们的dataloader

任务7:用之前先试试,整个数据和标签对应下,看看对不对

任务8:把做到的数据往模型里传

2.构建损失函数和优化器 

      训练函数


1.如何自定义数据集:

  • 1.数据和标签的目录结构先搞定(得知道到哪读数据)
  • 2.写好读取数据路径和标签路径的函数(根据自己数据集情况来写)
  • 3.完成单个数据与标签读取函数(给dataloader举一个例子)

咱们以花朵数据集为例:

  • 原来数据集都是以文件夹为类别ID,现在咱们换一个套路,用txt文件指定数据路径与标签(实际情况基本都这样)
  • 这回咱们的任务就是在txt文件中获取图像路径与标签,然后把他们交给dataloader
  • 核心代码非常简单,按照对应格式传递需要的数据和标签就可以啦
  • 需要到的flower数据集链接:https://pan.baidu.com/s/1RVAlr-uTczP2ZEHgFfdmVw 
                                                 提取码:micx 

 

 

train.txt:  指定图片名字和分类标签

image_06734.jpg 0
image_06735.jpg 0
image_06736.jpg 0
image_06737.jpg 0
image_06738.jpg 0
image_06740.jpg 0
image_06741.jpg 0

import os
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import torch
from torch import nn
import torch.optim as optim
import torchvision
#pip install torchvision
from torchvision import transforms, models, datasets
#https://pytorch.org/docs/stable/torchvision/index.html
import imageio
import time
import warnings
import random
import sys
import copy
import json
from PIL import Image

任务1:读取txt文件中的路径和标签

  • 第一个小任务,从标注文件中读取数据和标签
  • 至于你准备存成什么格式,都可以的,一会能取出来东西就行
def load_annotations(ann_file):
    data_infos = {}
    with open(ann_file) as f:  #打开文件
        samples = [x.strip().split(' ') for x in f.readlines()] #一行行去读,以空格作为切分,[ [xxx.jpg,'1' ],[xxx,jpg,'2' ]  ]
        for filename, gt_label in samples:  # filename为xxx.jpg,gt_label为分类值
            data_infos[filename] = np.array(gt_label, dtype=np.int64)#构建字典,图片名为key,分类值为value,组合
    return data_infos #返回字典

 返回的字典内容

关于strip()和split()函数用方法,参考博客Python中的strip().split(‘\t‘)的用法和解释_AI学习的我的博客-CSDN博客

任务2:通过上面字典返回数据,分别把数据和标签都存在list里

  • 不是我非让你存list里,因为dataloader到时候会在这里取数据
  • 按照人家要求来,不要耍个性,让整list咱就给人家整

img_label = load_annotations('./flower_data/train.txt')

image_name = list(img_label.keys())
label = list(img_label.values())

 image_name 和 label 列表的内容

 

任务3:图像数据路径得完整

  • 因为一会咱得用这个路径去读数据,所以路径得加上前缀
  • 以后大家任务不同,数据不同,怎么加你看着来就行,反正得能读到图像

data_dir = './flower_data/'
train_dir = data_dir + '/train_filelist'
valid_dir = data_dir + '/val_filelist'

image_path = [os.path.join(train_dir,img) for img in image_name] #根据图像路径和图像名字加载图片进来

任务4:把上面那几个事得写在一起,整合到一个类。

  • 1.注意要使用from torch.utils.data import Dataset, DataLoader
  • 2.类名定义class FlowerDataset(Dataset),其中FlowerDataset可以改成自己的名字
  • 3.def init(self, root_dir, ann_file, transform=None):咱们要根据自己任务重写
  • 4.def getitem(self, idx):根据自己任务,返回图像数据和标签数据,传给模型
from torch.utils.data import Dataset, DataLoader
class FlowerDataset(Dataset):  #继承Dataset     生成2个list,一个[包含图片路径],一个[图像对应的labels]
    def __init__(self, root_dir, ann_file, transform=None):
        self.ann_file = ann_file
        self.root_dir = root_dir
        self.img_label = self.load_annotations()#返回字典,图片名为key,图片label为value
        self.img = [os.path.join(self.root_dir,img) for img in list(self.img_label.keys())]#一个[包含图片路径]的list 
        self.label = [label for label in list(self.img_label.values())]# [图像对应的labels] 的list
        self.transform = transform
 
    def __len__(self): #数据集样本数量
        return len(self.img)
 # __getitem__会执行 batch_size次,__getitem__返回的数据是给模型的
    def __getitem__(self, idx):#图像和标签在当前list的索引,每次调用idx是随机值,一个batch里的数据是随机打乱的
        image = Image.open(self.img[idx])
        label = self.label[idx]
        if self.transform:  #取完图片后,进行预处理
            image = self.transform(image)
        label = torch.from_numpy(np.array(label)) #转回Tensor格式
        return image, label #返回实际图像 ,按batch_size大小数据打包好返回
    def load_annotations(self):
        data_infos = {}
        with open(self.ann_file) as f:
            samples = [x.strip().split(' ') for x in f.readlines()]
            for filename, gt_label in samples:
                data_infos[filename] = np.array(gt_label, dtype=np.int64)#将图片名和label组合成字典数据
        return data_infos

任务5:数据预处理(transform)

  • 1.预处理的事都在上面的getitem中完成,需要对图像和标签咋咋地的,要整啥事,都在上面整
  • 2.返回的数据和标签就是建模时模型的输入和损失函数中标签的输入,一定整明白自己模型要啥
  • 3.预处理这个事是你定的,不同的数据需要的方法也不一样,下面给出的是比较通用的方法

data_transforms = {
    'train': 
        transforms.Compose([
        transforms.Resize(64),
        transforms.RandomRotation(45),#随机旋转,-45到45度之间随机选
        transforms.CenterCrop(64),#从中心开始裁剪
        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.025),#概率转换成灰度率,3通道就是R=G=B
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])#均值,标准差
    ]),
    'valid': 
        transforms.Compose([
        transforms.Resize(64),
        transforms.CenterCrop(64),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
}

任务6:根据写好的class FlowerDataset(Dataset):来实例化咱们的dataloader

  • 1.构建数据集:分别创建训练和验证用的数据集(如果需要测试集也一样的方法)
  • 2.用Torch给的DataLoader方法来实例化(batch啥的自己定,根据你的显存来选合适的)
  • 3.打印看看数据里面是不是有东西了
train_dataset = FlowerDataset(root_dir=train_dir, ann_file = './flower_data/train.txt', transform=data_transforms['train'])

val_dataset = FlowerDataset(root_dir=valid_dir, ann_file = './flower_data/val.txt', transform=data_transforms['valid'])

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=64, shuffle=True)

任务7:用之前先试试,整个数据和标签对应下,看看对不对

  • 1.别着急往模型里传,对不对都不知道呢
  • 2.用这个方法:iter(train_loader).next()来试试,得到的数据和标签是啥
  • 3.看不出来就把图画出来,标签打印出来,确保自己整的数据集没啥问题

 

 

任务8:把做到的数据往模型里传

  • 下面这些事之前都唠过了,按照自己习惯的方法整就得了

dataloaders = {'train':train_loader,'valid':val_loader}

model_name = 'resnet'  #可选的比较多 ['resnet', 'alexnet', 'vgg', 'squeezenet', 'densenet', 'inception']
#是否用人家训练好的特征来做
feature_extract = True 


# 是否用GPU训练
train_on_gpu = torch.cuda.is_available()

if not train_on_gpu:
    print('CUDA is not available.  Training on CPU ...')
else:
    print('CUDA is available!  Training on GPU ...')
    
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

model_ft = models.resnet18() #上面先指定使用resnet,这里再指定使用多少层的模型



#重新定义输出层
num_ftrs = model_ft.fc.in_features #获取输出层的输入
model_ft.fc = nn.Sequential(nn.Linear(num_ftrs, 102))
input_size = 64 #输入图片的大小

2.构建损失函数和优化器 

# 优化器设置
optimizer_ft = optim.Adam(model_ft.parameters(), lr=1e-3)
scheduler = optim.lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)#学习率每7个epoch衰减成原来的1/10
criterion = nn.CrossEntropyLoss()

      训练函数

def train_model(model, dataloaders, criterion, optimizer, num_epochs=25, is_inception=False, filename='best.pth'):
    since = time.time()
    best_acc = 0
    model.to(device)

    val_acc_history = []
    train_acc_history = []
    train_losses = []
    valid_losses = []
    LRs = [optimizer.param_groups[0]['lr']]

    best_model_wts = copy.deepcopy(model.state_dict())

    for epoch in range(num_epochs):
        print('Epoch {}/{}'.format(epoch, num_epochs - 1))
        print('-' * 10)

        # 训练和验证
        for phase in ['train', 'valid']:
            if phase == 'train':
                model.train()  # 训练
            else:
                model.eval()   # 验证

            running_loss = 0.0
            running_corrects = 0

            # 把数据都取个遍
            for inputs, labels in dataloaders[phase]:
                inputs = inputs.to(device)
                labels = labels.to(device)

                # 清零
                optimizer.zero_grad()
                # 只有训练的时候计算和更新梯度
                with torch.set_grad_enabled(phase == 'train'):
                    outputs = model(inputs)
                    loss = criterion(outputs, labels)
                    _, preds = torch.max(outputs, 1)
                    #print(loss)

                    # 训练阶段更新权重
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()

                # 计算损失
                running_loss += loss.item() * inputs.size(0)
                running_corrects += torch.sum(preds == labels.data)

            epoch_loss = running_loss / len(dataloaders[phase].dataset)
            epoch_acc = running_corrects.double() / len(dataloaders[phase].dataset)
            
            
            time_elapsed = time.time() - since
            print('Time elapsed {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))
            print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))
            

            # 得到最好那次的模型
            if phase == 'valid' and epoch_acc > best_acc:
                best_acc = epoch_acc
                best_model_wts = copy.deepcopy(model.state_dict())
                state = {
                  'state_dict': model.state_dict(),#字典里key就是各层的名字,值就是训练好的权重
                  'best_acc': best_acc,
                  'optimizer' : optimizer.state_dict(),#优化器的状态信息
                }
                torch.save(state, filename)
            if phase == 'valid':
                val_acc_history.append(epoch_acc)
                valid_losses.append(epoch_loss)
                scheduler.step(epoch_loss)#学习率衰减
                
            if phase == 'train':
                train_acc_history.append(epoch_acc)
                train_losses.append(epoch_loss)
        
        print('Optimizer learning rate : {:.7f}'.format(optimizer.param_groups[0]['lr']))
        LRs.append(optimizer.param_groups[0]['lr'])
        print()

    time_elapsed = time.time() - since
    print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))
    print('Best val Acc: {:4f}'.format(best_acc))

    # 训练完后用最好的一次当做模型最终的结果,等着一会测试
    model.load_state_dict(best_model_wts)
    return model, val_acc_history, train_acc_history, valid_losses, train_losses, LRs 

       调用函数开始训练

model_ft, val_acc_history, train_acc_history, valid_losses, train_losses, LRs  = train_model(model_ft, dataloaders, criterion, optimizer_ft, num_epochs=20, filename='best.pth')

       训练结果:

Epoch 0/19
----------
Time elapsed 1m 48s
train Loss: 4.0150 Acc: 0.0804
Time elapsed 1m 55s
valid Loss: 3.5848 Acc: 0.1565
Optimizer learning rate : 0.0010000

Epoch 1/19
----------
Time elapsed 3m 37s
train Loss: 3.4320 Acc: 0.1601
Time elapsed 3m 44s
valid Loss: 3.4386 Acc: 0.1614
Optimizer learning rate : 0.0010000

Epoch 2/19

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值