1

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

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

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

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

4

1 回答 1

8

TLDR；

  1. 默认DataLoader只使用采样器，而不是批处理采样器。

  2. 你可以定义一个采样器，加上一个批处理采样器，一个批处理采样器将覆盖采样器。

  3. 采样器只产生数据集元素的序列，而不是实际的批次（这由数据加载器处理，取决于batch_size）。

要回答您最初的问题：在可迭代数据集上使用采样器似乎是不可能的。 Github问题（仍然开放）。另外，请阅读以下关于pytorch/dataloader.py.

采样器（用于地图样式数据集）：

除此之外，如果您要切换到地图样式的数据集，这里有一些关于采样器和批处理采样器如何工作的详细信息。您可以使用索引访问数据集的基础数据，就像使用列表一样（从torch.utils.data.Datasetimplements开始__getitem__）。换句话说，您的数据集元素都是dataset[i], for iin [0, len(dataset) - 1]。

这是一个玩具数据集：

class DS(Dataset):
    def __getitem__(self, index):
        return index
        
    def __len__(self):
        return 10

在一般用例中，您只需给出torch.utils.data.DataLoader参数batch_size和shuffle. 默认情况下，shuffle设置为false，这意味着它将使用torch.utils.data.SequentialSampler. 否则（如果shuffle是true）torch.utils.data.RandomSampler将被使用。采样器定义数据加载器如何访问数据集（访问它的顺序）。

上述数据集 ( DS) 有10 个元素。指数为0, 1, 2, 3, 4, 5, 6, 7, 8, 和9. 它们映射到元素0, 10, 20, 30, 40, 50, 60, 70, 80, 和90. 所以批量大小为2：

  • SequentialSampler: DataLoader(ds, batch_size=2)（含蓄shuffle=False地），等同于DataLoader(ds, batch_size=2, sampler=SequentialSampler(ds)). 数据加载器将提供tensor([0, 10])、tensor([20, 30])、tensor([40, 50])、tensor([60, 70])和tensor([80, 90])。

  • RandomSampler: DataLoader(ds, batch_size=2, shuffle=True), 等同于DataLoader(ds, batch_size=2, sampler=RandomSampler(ds)). 每次迭代时，数据加载器都会随机采样。例如：tensor([50, 40])、tensor([90, 80])、tensor([0, 60])、 tensor([10, 20])和tensor([30, 70])。但是如果您第二次遍历数据加载器，顺序会有所不同！

批量采样器

提供batch_sampler将覆盖 batch_size, shuffle, sampler, 和drop_last完全。它旨在准确定义批处理元素及其内容。例如：

>>> DataLoader(ds, batch_sampler=[[1,2,3], [6,5,4], [7,8], [0,9]])`

将产生tensor([10, 20, 30]), tensor([60, 50, 40]),tensor([70, 80])和tensor([ 0, 90]).

对班级进行批量抽样

假设我只想在我的批次中每个类有 2 个元素（不同或不同），并且必须排除每个类的更多示例。因此，请确保批次中没有 3 个示例。

假设您有一个包含四个类的数据集。这是我将如何做到的。首先，跟踪每个类的数据集索引。

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

        self.indices = [[] for _ in range(4)]
        for i, x in enumerate(data):
            if x > 0 and x % 2: self.indices[0].append(i)
            if x > 0 and not x % 2: self.indices[1].append(i)
            if x < 0 and x % 2: self.indices[2].append(i)
            if x < 0 and not x % 2: self.indices[3].append(i)

    def classes(self):
        return self.indices

    def __getitem__(self, index):
        return self.data[index]

例如：

>>> ds = DS([1, 6, 7, -5, 10, -6, 8, 6, 1, -3, 9, -21, -13, 11, -2, -4, -21, 4])

会给：

>>> ds.classes()
[[0, 2, 8, 10, 13], [1, 4, 6, 7, 17], [3, 9, 11, 12, 16], [5, 14, 15]]

然后对于批处理采样器，最简单的方法是创建一个可用的类索引列表，并且具有与数据集元素一样多的类索引。

在上面定义的数据集中，我们有来自 class 的5 个项目，来自 class0的5个项目，来自class1的5个项目，来自class2的33个项目。因此我们要构造[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3]. 我们将对其进行洗牌。然后，从这个列表和数据集类内容 ( ds.classes()) 我们将能够构建批次。

class Sampler():
    def __init__(self, classes):
        self.classes = classes

    def __iter__(self):
        classes = copy.deepcopy(self.classes)
        indices = flatten([[i for _ in range(len(klass))] for i, klass in enumerate(classes)])
        random.shuffle(indices)
        grouped = zip(*[iter(indices)]*2)

        res = []
        for a, b in grouped:
            res.append((classes[a].pop(), classes[b].pop()))
        return iter(res)

注意- 需要深度复制列表，因为我们要从中弹出元素。

此采样器的可能输出为：

[(15, 14), (16, 17), (7, 12), (11, 6), (13, 10), (5, 4), (9, 8), (2, 0), (3, 1)]

此时我们可以简单地使用torch.data.utils.DataLoader：

>>> dl = DataLoader(ds, batch_sampler=sampler(ds.classes()))

这可能会产生类似的东西：

[tensor([ 4, -4]), tensor([-21,  11]), tensor([-13,   6]), tensor([9, 1]), tensor([  8, -21]), tensor([-3, 10]), tensor([ 6, -2]), tensor([-5,  7]), tensor([-6,  1])]

更简单的方法

这是另一种更简单的方法，它不能保证从数据集中返回所有元素，平均而言它会......

对于每个批次，首先采样class_per_batch类，然后batch_size从这些选定的类中采样元素（首先从该类子集中采样一个类，然后从该类的一个数据点采样）。

class Sampler():
    def __init__(self, classes, class_per_batch, batch_size):
        self.classes = classes
        self.n_batches = sum([len(x) for x in classes]) // batch_size
        self.class_per_batch = class_per_batch
        self.batch_size = batch_size

    def __iter__(self):
        classes = random.sample(range(len(self.classes)), self.class_per_batch)
        
        batches = []
        for _ in range(self.n_batches):
            batch = []
            for i in range(self.batch_size):
                klass = random.choice(classes)
                batch.append(random.choice(self.classes[klass]))
            batches.append(batch)
        return iter(batches)

你可以这样尝试：

>>> s = Sampler(ds.classes(), class_per_batch=2, batch_size=4)
>>> list(s)
[[16, 0, 0, 9], [10, 8, 11, 2], [16, 9, 16, 8], [2, 9, 2, 3]]

>>> dl = DataLoader(ds, batch_sampler=s)
>>> list(iter(dl))
[tensor([ -5,  -6, -21, -13]), tensor([ -4,  -4, -13, -13]), tensor([ -3, -21,  -2,  -5]), tensor([-3, -5, -4, -6])]
于 2021-02-05T17:36:45.100 回答