Pytorch模型训练-----------数据集加载之ImageFolder之全过程

最新推荐文章于 2024-07-16 18:10:07 发布
最新推荐文章于 2024-07-16 18:10:07 发布
阅读量5.5k 收藏 44
点赞数 6
分类专栏： pytorch模型加载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ahelloyou/article/details/115185996
版权

数据集加载之ImageFolder

ImageFolder一个通用的数据加载器，数据集中的数据以以下方式组织

函数如下

ImageFolder(root, transform``=``None``, target_transform``=``None``, loader``=``default_loader)

参数解释

  • root 指定路径加载图片

  • transform：对PIL Image进行的转换操作，transform的输入是使用loader读取图片的返回对象

  • target_transform：对label的转换

  • loader：给定路径后如何读取图片，默认读取为RGB格式的PIL Image对象

label是按照文件夹名顺序排序后存成字典，即{类名:类序号(从0开始)}，一般来说最好直接将文件夹命名为从0开始的数字，这样会和ImageFolder实际的label一致，如果不是这种命名规范，建议看看self.class_to_idx属性以了解label和文件夹名的映射关系

img

可见分成了cat和dog两类

import torchvision.datasets as dset
dataset = dset.ImageFolder('./data/dogcat_2') #没有transform，先看看取得的原始图像数据
print(dataset.classes)  #根据分的文件夹的名字来确定的类别
print(dataset.class_to_idx) #按顺序为这些类别定义索引为0,1...
print(dataset.imgs) #返回从所有文件夹中得到的图片的路径以及其类别

返回

['cat', 'dog']
{'cat': 0, 'dog': 1}
[('./data/dogcat_2/cat/cat.12484.jpg', 0), ('./data/dogcat_2/cat/cat.12485.jpg', 0), ('./data/dogcat_2/cat/cat.12486.jpg', 0), ('./data/dogcat_2/cat/cat.12487.jpg', 0), ('./data/dogcat_2/dog/dog.12496.jpg', 1), ('./data/dogcat_2/dog/dog.12497.jpg', 1), ('./data/dogcat_2/dog/dog.12498.jpg', 1), ('./data/dogcat_2/dog/dog.12499.jpg', 1)]

查看得到的图片数据：

#从返回结果可见得到的数据仍是PIL Image对象
print(dataset[0])
print(dataset[0][0])
print(dataset[0][1]) #得到的是类别0，即cat

返回：

(<PIL.Image.Image image mode=RGB size=497x500 at 0x11D99A9B0>, 0)
<PIL.Image.Image image mode=RGB size=497x500 at 0x11DD24278>
0

再通过transform变成张量

 data_transform = {
        "train": transforms.Compose([transforms.RandomResizedCrop(224),
                                     transforms.RandomHorizontalFlip(),
                                     transforms.ToTensor()
                                     ]),
        "val": transforms.Compose([transforms.Resize((224, 224)),  # cannot 224, must (224, 224)
                                   transforms.ToTensor()
                                   ])}

    train_dataset = datasets.ImageFolder(root=os.path.join(data_root, "train"),
                                         transform=data_transform["train"])
    
    print(train_dataset[0])
	print(train_dataset[0][0])
	print(train_dataset[0][1]) #得到的是类别0，即cat

得到

(tensor([[[0.3765, 0.3765, 0.3765,  ..., 0.3765, 0.3765, 0.3765],
         [0.3765, 0.3765, 0.3765,  ..., 0.3765, 0.3765, 0.3765],
         [0.3804, 0.3804, 0.3804,  ..., 0.3765, 0.3765, 0.3765],
         ...,
         [0.4941, 0.4941, 0.4902,  ..., 0.3804, 0.3765, 0.3765],
         [0.5098, 0.5098, 0.5059,  ..., 0.3804, 0.3765, 0.3765],
         [0.5098, 0.5098, 0.5059,  ..., 0.3804, 0.3765, 0.3765]],

        [[0.5686, 0.5686, 0.5686,  ..., 0.5843, 0.5804, 0.5804],
         [0.5686, 0.5686, 0.5686,  ..., 0.5843, 0.5804, 0.5804],
         [0.5725, 0.5725, 0.5725,  ..., 0.5843, 0.5804, 0.5804],
         ...,
         [0.5686, 0.5686, 0.5686,  ..., 0.5961, 0.5922, 0.5922],
         [0.5686, 0.5686, 0.5686,  ..., 0.5961, 0.5922, 0.5922],
         [0.5686, 0.5686, 0.5686,  ..., 0.5961, 0.5922, 0.5922]],

        [[0.4824, 0.4824, 0.4824,  ..., 0.4902, 0.4902, 0.4902],
         [0.4824, 0.4824, 0.4824,  ..., 0.4902, 0.4902, 0.4902],
         [0.4863, 0.4863, 0.4863,  ..., 0.4902, 0.4902, 0.4902],
         ...,
         [0.3647, 0.3686, 0.3804,  ..., 0.4824, 0.4784, 0.4784],
         [0.3451, 0.3490, 0.3608,  ..., 0.4824, 0.4784, 0.4784],
         [0.3451, 0.3490, 0.3608,  ..., 0.4824, 0.4784, 0.4784]]]), 0)
         
         省略
         图像Tensor [........]
         标签Tensor [0]

可以知道train_dataset[0]是一个tuple里面一个是张量一个是标量

    print(train_dataset[0][0].shape)
    print(train_dataset[0][1])

返回

torch.Size([3, 224, 224])
0

DataLoader产生批训练数据

for epoch in range(epoch_num):
        for image, label in train_loader:
			print("label: ", labels, labels.dtype)
            print("imges: ", images, images.dtype)

返回

label:  tensor([0]) torch.int64
    
imges:  tensor([[[[0.2275, 0.2275, 0.2235,  ..., 0.2196, 0.2196, 0.2196],
          [0.2275, 0.2275, 0.2235,  ..., 0.2196, 0.2196, 0.2196],
          [0.2235, 0.2235, 0.2235,  ..., 0.2157, 0.2157, 0.2157],
          ...,
          [0.2392, 0.2392, 0.2392,  ..., 0.2235, 0.2235, 0.2235],
          [0.2353, 0.2353, 0.2353,  ..., 0.2235, 0.2275, 0.2275],
          [0.2353, 0.2353, 0.2353,  ..., 0.2235, 0.2275, 0.2275]],

         [[0.2392, 0.2392, 0.2353,  ..., 0.2275, 0.2275, 0.2275],
          [0.2392, 0.2392, 0.2353,  ..., 0.2275, 0.2275, 0.2275],
          [0.2353, 0.2353, 0.2353,  ..., 0.2235, 0.2235, 0.2235],
          ...,
          [0.2275, 0.2275, 0.2314,  ..., 0.2196, 0.2196, 0.2196],
          [0.2235, 0.2235, 0.2275,  ..., 0.2196, 0.2196, 0.2196],
          [0.2235, 0.2235, 0.2275,  ..., 0.2196, 0.2196, 0.2196]],

         [[0.1961, 0.1961, 0.1961,  ..., 0.1765, 0.1765, 0.1765],
          [0.1961, 0.1961, 0.1961,  ..., 0.1765, 0.1765, 0.1765],
          [0.1922, 0.1922, 0.1922,  ..., 0.1725, 0.1725, 0.1725],
          ...,
          [0.1529, 0.1529, 0.1529,  ..., 0.1686, 0.1686, 0.1686],
          [0.1490, 0.1490, 0.1490,  ..., 0.1686, 0.1686, 0.1686],
          [0.1490, 0.1490, 0.1490,  ..., 0.1686, 0.1686, 0.1686]]]]) torch.float32

enumerate加载

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

可以用这个循环加载batchsize下面的每一元组，来得到相应的图片及标签

多元素赋值

当Python检测到等号左边是多个变量，右边是list或者是tuple之后，会自动执行list和tuple的解压，将它依次赋值给对应的元素：

l = [1, 2]
a, b = l

所以可以

for step, data in enumerate(train_bar):
            images, labels = data

最后nn.CrossEntropyLoss()计算loss回归

nn.CrossEntropyLoss()是nn.logSoftmax()和nn.NLLLoss()的整合,可以直接使用它来替换网络中的这两个操作。下面我们来看一下计算过程。

img

其中x是网络的输出向量，class是真实标签

举个例子，一个三分类网络对某个输入样本的输出为[-0.7715, -0.6205,-0.2562]，该样本的真实标签为0，则用nn.CrossEntropyLoss()计算的损失为

img

参考链接讲的很好

参考二

黑猫爱小鹿
关注
  • 6
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Pytorch快速入门系列---（九）Pytorch对预训练好的VGG16模型进行微调
qq_42681787的博客
03-21 2935
对于一个复杂的卷积神经网络来说，通常网络的层数非常大，网络的深度非常深、网络的参数非常多，单单设计一个卷积网络就需要颇费心思，何况网络还需要大量的数据集进行漫长时间的训练，若没有一个好的算力平台也很难迅速训练出模型。可见，从头到尾搭建一个中等规模的卷积神经网络对于我们来说绝非易事。幸运的是PyTorch已经许多预训练好的模型，比如内置了使用ImageNet数据集预训练好的、流行的VGG、AlexNet等深度学习网络，我们可以针对自己的需求，对预训练好的网络进行微调，从而快速完成自己的任务。
【ChatGPT模型精调训练】AI 大模型精调 Fine-Tuning （微调）训练图文代码实战详解
光剑书架上的书
03-09 727
选择预训练模型：选择一个在类似任务上已经训练好的模型作为起点。数据准备：准备并预处理你的数据集，使其适合模型的输入格式。微调：在你的特定数据集上继续训练模型，调整模型的权重。评估：评估微调后模型的性能。应用：将微调后的模型部署到实际应用中。Fine-Tuning（精调）是指在预训练模型的基础上，对模型进行微调，使其适应特定任务。预训练模型通常在大量无标签数据上进行训练，以学习通用的语言表示。通过 Fine-Tuning，我们可以在较小的标签数据集上训练模型，以便模型能够更好地解决特定任务。
python torchvision_pytorch torchvision.ImageFolder的用法介绍
weixin_39633134的博客
12-21 224
torchvision.datasetsDatasets 拥有以下API:__getitem____len__Datasets都是 torch.utils.data.Dataset的子类，所以，他们也可以通过torch.utils.data.DataLoader使用多线程(python的多进程)。举例说明：torch.utils.data.DataLoader(coco_cap, batch_si...
数据集读取与划分，ImageFolder()，自定义数据集，TensorDataset，StratifiedShuffleSplit
iwill323的博客
11-04 3901
数据集读取和划分 torchvision.datasets.ImageFolder() StratifiedShuffleSplit TensorDataset
torchvision.datasets.ImageFolder（最详细功能总结）
最新发布
qq_61668277的博客
07-16 191
从前8个和后8个样本中分别取出图像部分并显示。数据集按类别放在不同的子文件夹中。
Pytorch中ImageFolder的使用，如何使用Pytorch加载本地Imagenet的训练集与验证集，Imagenet 2012验证集的分类
weixin_41466947的博客
03-13 1万+
Pytorch中ImageFolder的使用，如何使用Pytorch加载本地Imagenet的训练集与验证集 torchvision 中有一个常用的数据集类 ImageFolder，它假定了数据集是以如下方式构造的: root/ants/xxx.png root/ants/xxy.jpeg root/ants/xxz.png . . . root/bees/123.jpg root/bees/ns...
pytorch读取数据集(分类文件夹加载)—ImageFolder()
zzy_pphz的博客
03-07 1万+
马上本科毕业了，毕业设计内容和图像深度学习有关，数据集在网上找了很久才找到，找到的数据集按类别存放在相应文件夹、没有标签文件。我不知道怎么读取，在CSDN上找了好久，只有很少的文章里提到了文件夹读取，但是也没有详细说明，大多数都是用标签读取的。 而且CSDN上将深度学习入门的博客大都直接用MNIST等一些可以直接使用的数据集，很少讲用自己的数据集的。 现在我的问题解决了，自己写一...
MindSpore易点通·精讲系列--数据集加载之ImageFolderDataset
kaierlong的博客
06-21 1806
MindSpore易点通·精讲系列--数据集加载之ImageFolderDataset
pytorch通过ImageFolder函数读取数据集（详细实例）
wqy1837154675的博客
08-14 7677
pytorch通过ImageFolder函数读取数据集（详细实例） dataset = ImageFolder(“E:/pycharmproject/dataset_read/veg200_images/”, transform=data_transform) #主要有两个参数，一个是图像根目录（被映射成标签的子目录的上一级），一个是数据操作 本文理论参考，以下博客的方法二：https://blog.csdn.net/qq_36852276/article/details/94588656 1 代码 #通过
视频教程-深度学习-Pytorch项目实战－垃圾分类-深度学习
weixin_33893455的博客
05-28 2014
深度学习-Pytorch项目实战－垃圾分类 JAVA企业级应用讲师、大数据实...
Pytorch自己加载单通道图片用作数据集训练的实例
09-18
在本篇关于PyTorch加载单通道图片作为数据集进行训练的实例中，我们将会接触到几个关键的PyTorch组件以及它们在处理单通道图片时的具体应用方法。在PyTorch中，使用torchvision包来加载和处理图像数据集是最为常见的...
Pytorch快速入门系列---（十六）Pytorch实现图像风格迁移（二）
qq_42681787的博客
04-05 898
本节介绍使用PyTorch对固定风格任意内容的快速风格迁移进行建模。该模型根据下图所示的网络及训练过程进行建模,但略有改动，主要对图像转换网络的上采样操作进行相应的调整。在下面建立的网络中，将会使用转置卷积操作进行特征映射的上采样。
pytorch读取自己的数据集进行训练
shizuguilai的博客
12-13 1821
pytorch读取自定义数据集。多种方法实现。
ImageFolder类上添加划分数据集和打乱数据的功能
Alex抱着爆米花的博客
11-30 2814
问题描述 ImageFolder是一个非常有用的类，只要数据集按照要求规范文件，就可以很轻松的，得到 文件路径和类型 的元祖。同时加载DataLoader 也非常方便，但是在实际用的时候发现缺少了划分数据集的功能，并且是按照数据也是按照文件夹依次得到的，这对划分数据集上非常不利的。 解决 通过阅读ImageFolder源码并在其基础上继承并添加自己的功能。 import time import torch import visdom import torchvision from torchvision
torchvision.datasets.ImageFolder()使用详解
热门推荐
MOL
03-23 4万+
一、数据集组织方式 ImageFolder是一个通用的数据加载器，它要求我们以下面这种格式来组织数据集的训练、验证或者测试图片。 root/dog/xxx.png root/dog/xxy.png root/dog/xxz.png root/cat/123.png root/cat/nsdf3.png root/cat/asd932_.png 对于上面的root，假设data文件夹在.py文件的同级目录中，那么root一般都是如下这种形式：./data/train 和 ./data/valid
PyTorch 07： PyTorch加载图像数据
科学边界
05-15 1677
到目前为止，我们一直使用的都是虚拟数据集。但在实际运用里，你会处理一些完整尺寸的图像，例如智能手机摄像头拍摄的图像。现在，我们将学习如何加载图像并使用它们训练神经网络。 我们将使用猫狗照片数据集（从 Kaggle 上可以获得）。下面是几个示例图像： 我们将使用该数据集训练神经网络区分猫和狗。五年前，这对于计算机视觉系统来说，是一项巨大的挑战。现在，它的应用就很普遍了。 %matplotlib inline %config InlineBackend.figure_format = 'retina' im
Pytorch加载图像数据
陨星落云的博客
04-20 992
加载图像数据 到目前为止，我们一直在使用自带的数据集，您通常不会在实际项目中使用这些数据集。 相反，您可能会像从智能手机相机中获取的那样处理图像。 在本部分内容中，我们将研究如何加载图像并将其用于训练神经网络。 我们将使用Kaggle提供的猫狗数据集。 这是几个示例图像： 我们将使用该数据集来训练可区分猫和狗的神经网络。 如今，这似乎不是一个很大的成就，但是五年前，对于计算机视觉系统来说，这是一...
使用vgg16训练自己的数据集进行图像分类
qq_41319665的博客
03-03 1万+
使用VGG16网络训练自己的图片分类网络
调用任意框架，完成对tiny-imagenet的训练过程和分类预测
05-19
好的，我可以用PyTorch框架完成这个任务。首先需要下载tiny-imagenet数据集并准备数据。接着，我们可以按照以下步骤进行训练和预测： 1. 加载数据集 我们需要使用PyTorch的Dataset和DataLoader类来加载tiny-imagenet数据集。在加载数据集时，我们需要进行数据增强（如随机剪裁、水平翻转等）以提高模型的泛化能力。 ```python import torch import torchvision.transforms as transforms import torchvision.datasets as datasets # 定义数据增强 train_transforms = transforms.Compose([ transforms.RandomResizedCrop(64), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) test_transforms = transforms.Compose([ transforms.Resize(64), transforms.CenterCrop(64), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) # 加载数据集 train_dataset = datasets.ImageFolder('/path/to/tiny-imagenet/train', transform=train_transforms) test_dataset = datasets.ImageFolder('/path/to/tiny-imagenet/val', transform=test_transforms) # 定义DataLoader train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle=False) ``` 2. 定义模型 我们可以使用预训练的ResNet-18模型，并将其最后一层替换为一个全连接层以适应tiny-imagenet数据集。 ```python import torchvision.models as models import torch.nn as nn # 加载预训练的ResNet-18模型 model = models.resnet18(pretrained=True) # 替换最后一层为一个全连接层，并使用xavier初始化权重 model.fc = nn.Linear(512, 200) nn.init.xavier_uniform_(model.fc.weight) # 将模型移动到GPU上 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = model.to(device) ``` 3. 定义损失函数和优化器 我们可以使用交叉熵损失函数来训练模型，并使用随机梯度下降（SGD）优化器进行参数优化。 ```python import torch.optim as optim criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=1e-4) ``` 4. 训练模型 我们可以使用以下代码来训练模型： ```python # 定义训练函数 def train(model, device, train_loader, criterion, optimizer, epoch): model.train() running_loss = 0.0 for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() running_loss += loss.item() * data.size(0) train_loss = running_loss / len(train_loader.dataset) print('Train Epoch: {} \t Loss: {:.6f}'.format(epoch, train_loss)) # 训练模型 for epoch in range(1, 21): train(model, device, train_loader, criterion, optimizer, epoch) ``` 5. 测试模型 我们可以使用以下代码来测试模型： ```python # 定义测试函数 def test(model, device, test_loader): model.eval() correct = 0 with torch.no_grad(): for data, target in test_loader: data, target = data.to(device), target.to(device) output = model(data) pred = output.argmax(dim=1, keepdim=True) correct += pred.eq(target.view_as(pred)).sum().item() acc = 100. * correct / len(test_loader.dataset) print('Test Accuracy: {:.2f}%'.format(acc)) # 测试模型 test(model, device, test_loader) ``` 6. 预测新图片 我们可以使用以下代码来预测新图片： ```python import PIL.Image as Image # 定义类别名称 class_names = train_dataset.classes # 加载图片并进行预处理 img = Image.open('/path/to/image.jpg') img_transforms = test_transforms(img).unsqueeze(0) # 将图片移动到GPU上 img_transforms = img_transforms.to(device) # 预测图片的类别 output = model(img_transforms) pred = output.argmax(dim=1, keepdim=True).item() # 打印预测结果 print('Predicted Class:', class_names[pred]) ``` 这样，我们就完成了对tiny-imagenet的训练过程和分类预测。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值