标签: pytorch-dataloader

我是 PyTorch 的新手。奇怪的是，我找不到与此相关的任何内容，尽管它看起来很简单。

我想用特定的示例来构建我的批次，例如每批次的所有示例都具有相同的标签，或者只是用仅 2 个类的示例填充批次。

我该怎么做呢？对我来说，这似乎是数据加载器中的正确位置，而不是数据集中的正确位置？由于数据加载器负责批次而不是数据集？

有一个简单的最小示例吗？

我正在使用 PyTorch 框架训练我的神经网络。数据是全高清图像 (1920x1080)。但是在每次迭代中，我只需要从这些图像中裁剪出一个随机的 256x256 补丁。我的网络相对较小（5 个卷积层），因此瓶颈是由加载数据引起的。我在下面提供了我当前的代码。有什么方法可以优化加载数据并加快训练速度？

代码：

from pathlib import Path

import numpy
import skimage.io
import torch.utils.data as data

import Imath
import OpenEXR


class Ours(data.Dataset):
    """
    Loads patches of resolution 256x256. Patches are selected such that they contain atleast 1 unknown pixel
    """

    def __init__(self, data_dirpath, split_name, patch_size):
        super(Ours, self).__init__()
        self.dataroot = Path(data_dirpath) / split_name
        self.video_names = []
        for video_path in sorted(self.dataroot.iterdir()):
            for i in range(4):
                for j in range(11):
                    view_num = i * 12 + j
                    self.video_names.append((video_path.stem, …

我正在图像数据库上训练神经网络。我的图像具有全高清 (1920 x 1080) 分辨率，但为了训练，我使用大小为 256x256 的随机裁剪。由于读取完整图像然后裁剪效率不高，因此我使用 numpy memmap 仅加载 256x256 裁剪图像。也就是说，我正在做类似下面的事情

image_mmap = numpy.load(npy_image_path.as_posix(), mmap_mode=mmap_mode)
cropped_image = image_mmap[y1:y2, x1:x2]

由于在每个 epoch 中都会加载相同的图像，因此最初在每个 epoch 中加载所有 memmap 是否会更好，只需调用上面的第二行来获取裁剪后的图像？

PS：我已经尝试了这两种方法，但我并没有真正发现它们之间有很大的区别。我的直觉表明在__init__函数中加载所有内存映射应该比在每个时期一次又一次加载内存映射更好，但事实并非如此。如果你能解释为什么会发生这种情况，那也会对我有帮助。

尽管两种方法对我来说效果相似，但我问这个问题的原因是，我想知道未来的最佳实践是什么。

我目前正在与torch.nn.CrossEntropyLoss. 据我所知，批量计算损失是很常见的。但是，是否有可能计算多个批次的损失？

更具体地说，假设我们给出了数据

import torch

features = torch.randn(no_of_batches, batch_size, feature_dim)
targets = torch.randint(low=0, high=10, size=(no_of_batches, batch_size))

loss_function = torch.nn.CrossEntropyLoss()

有没有一种方法可以一行计算

loss = loss_function(features, targets) # raises RuntimeError: Expected target size [no_of_batches, feature_dim], got [no_of_batches, batch_size]

？

先感谢您！

我想在我的脚本中使用数据加载器。

通常默认的函数调用是这样的。

dataset = ImageFolderWithPaths(
    data_dir,
    transforms.Compose([
            transforms.ColorJitter(0.1, 0.1, 0.1, 0.1),
            transforms.Resize((img_size_XY, img_size_XY)),
            transforms.ToTensor(),
            transforms.Normalize(_mean , _std)
        ])
)

dataloader = torch.utils.data.DataLoader(
    dataset,
    batch_size=batch_size,
    shuffle=False,
    num_workers=2
)

并迭代我使用的这个数据加载器

for inputs, labels , paths in _dataloader:
    break

现在我需要收集每个图像的路径。

我在github中找到了这段代码：（https://gist.github.com/andrewjong/6b02ff237533b3b2c554701fb53d5c4d）

class ImageFolderWithPaths(datasets.ImageFolder):
    """Custom dataset that includes image file paths. Extends
    torchvision.datasets.ImageFolder
    """

    # override the __getitem__ method. this is the method that dataloader calls
    def __getitem__(self, index):
        # this is what ImageFolder normally returns 
        original_tuple = super(ImageFolderWithPaths, self).__getitem__(index)
        # the …

我正在尝试让 PyTorch 与 DataLoader 一起使用，据说这是处理小批量的最简单方法，在某些情况下这是获得最佳性能所必需的。

DataLoader 想要一个数据集作为输入。

大多数关于数据集的文档都假设您正在使用现成的标准数据集（例如 MNIST），或者至少使用图像，并且可以使用现有的机器作为黑匣子。我正在处理自己生成的非图像数据。我当前最好的尝试是，将有关如何执行此操作的文档提炼为最小的测试用例：

import torch
from torch import nn
from torch.utils.data import Dataset, DataLoader


class Dataset1(Dataset):
    def __init__(self):
        pass

    def __len__(self):
        return 80

    def __getitem__(self, i):
        # actual data is blank, just to test the mechanics of Dataset
        return [0.0, 0.0, 0.0], 1.0


train_dataloader = DataLoader(Dataset1(), batch_size=8)

for X, y in train_dataloader:
    print(f"X: {X}")
    print(f"y: {y.shape} {y.dtype} {y}")
    break


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.layers = nn.Sequential(
            nn.Linear(3, 10),
            nn.ReLU(),
            nn.Linear(10, 1),
            nn.Sigmoid(), …

以下数据集类 -> dataloader 仅适用于 num_workers = 0，我不确定为什么。同一环境中的其他笔记本确实可以在 num_workers > 0 的情况下工作。这已经困扰我好几个月了！

不起作用的类：没有错误消息，只是在 next(iter(train_dl)) 上无限期地运行，而 num_workers = 0 则需要 1 秒。

class SegmentationDataSet(data.Dataset):
def __init__(self, fnames, rle_df=None, path=train_val_dir):
    
    self.fnames = fnames
    self.rle_df = rle_df
    self.path = path

def __len__(self):
    return len(self.fnames)

def __getitem__(self, index:int):           
    img_id = self.fnames[index]
    mask = None
    im = torchvision.io.read_image(self.path + img_id).float()
    
    if self.rle_df is not None:
        rle = self.rle_df.loc[self.rle_df['id']==img_id]['rle']

        if not pd.isnull(rle).values[0]:
            rle = rle.values[0]
            mask = rle2mask(rle, [1024,1024])
            mask = torch.from_numpy(np.expand_dims(mask,0))
        else:
            mask = torch.zeros([1,1024,1024])
            
    return …

我\xc2\xb4m使用带有 M1 芯片的 Mac尝试 PyTorch 的DCGAN 教程。

由于某种原因，当使用数据加载器加载图像时，使用以下命令时生成的样本会损坏：device = torch.device("mps")。但使用时device = torch.device("cpu")我得到正确的结果，如下所示：

我检查了我的环境中 MPS 的配置是否正确。我正在使用 PyTorch 的 nightly build，它在我的 MacOs 版本上支持 MPS 加速。

这是一个已知的问题？

我想在 ImageNet 数据集（1000 个类别）上训练分类器，并且需要每个批次包含来自同一类别的 64 个图像以及来自不同类别的连续批次。到目前为止，根据我@shai的建议和这篇文章

import torchvision.transforms as transforms
import torchvision.datasets as datasets
from torch.utils.data import DataLoader
from torch.utils.data import Dataset
import numpy as np
import random
import argparse
import torch
import os


class DS(Dataset):
    def __init__(self, data, num_classes):
        super(DS, self).__init__()
        self.data = data

        self.indices = [[] for _ in range(num_classes)]
        for i, (data, class_label) in enumerate(data):
            # create a list of lists, where every sublist containts the indices of
            # the samples that belong to …

我想知道 PyTorch Dataloader 是否也可以将完整的数据集提取到 RAM 中，以便在有足够的 RAM 可用的情况下性能不会受到影响