1

我正在寻找一种将两个数据集连接到一个的方法，以便可以在一个循环中对其进行训练。然而，批次不允许在数据集之间混合。在以下示例中，批次应仅在 1 到 10 和 41 到 50 之间：

import pandas as pd
import torch
from torch.utils.data import Dataset, DataLoader, ConcatDataset

df1 = pd.DataFrame(list(range(1,11)))
df2 = pd.DataFrame(list(range(41,51)))

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

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

testdataset1 = testset(df1)
testdataset2 = testset(df2)

datasets = []
datasets.append(testdataset1)
datasets.append(testdataset2)

concat_dataset = ConcatDataset(datasets)

loader = DataLoader(
    concat_dataset,
    shuffle=False,
    num_workers=0,
    batch_size=3
)

for data in loader:
    print(data)

张量（[1, 2, 3]）

张量（[4, 5, 6]）

张量（[7, 8, 9]）

tensor([10, 41, 42]) ← 那不应该存在

张量（[43, 44, 45]）

张量（[46, 47, 48]）

张量（[49, 50]）

在实际情况中，我将两个时间序列组合在一起，其中两个数据集的值分批重叠会导致一些麻烦……</p>

这不应该是一个尽管如此，对吧？

4

1 回答 1

0

如果这样做，您将不再创建随机批次（这些是伪随机的），因为批次元素受到限制（如果第一个元素来自0数据集，则其余元素也必须如此）。

简短的介绍：

  • batch_size必须指定（因为样本生成取决于它）
  • 可选length参数，因为现在这个数据集可以是任意长度（样本是通过modulo操作从某个数据集中获取的）
  • 从数据集开始0并从中生成批次
  • 移动到另一个数据集（您可以在方法内切换__getitem__）：
    • 随机：方法_new_random_dataset
    • 只是下一个：方法_next_dataset

下面是一个torch.utils.data.Dataset自定义实例，它可以满足您的需求：

class Merger(torch.utils.data.Dataset):
    def __init__(
        self, *datasets: torch.utils.data.Dataset, batch_size: int, length: int = None
    ):
        self.datasets = datasets
        self.batch_size = batch_size

        if length is None:
            self._len = sum(len(d) for d in self.datasets)
        else:
            self._len = length

        # Keep in internal var how many items we've generated
        # Only possible dataset switch when new batch is created
        self._items_generated = 0
        # First batch will always go from the 0th dataset
        self._dataset_index = 0

    def __len__(self):
        return self._len

    def _next_dataset(self):
        if self._dataset_index == len(self.datasets) - 1:
            self._dataset_index = 0
        else:
            self._dataset_index += 1

    def _new_random_dataset(self):
        self._dataset_index = random.randrange(0, len(self.datasets))

    def __getitem__(self, index):
        if self._items_generated >= self.batch_size:
            self._items_generated = 0
            # self._next_dataset()
            self._new_random_dataset()

        self._items_generated += 1
        return self.datasets[self._dataset_index][
            index % len(self.datasets[self._dataset_index])
        ]

以及示例用法供您验证：

df1 = pd.DataFrame(list(range(1, 11)))
df2 = pd.DataFrame(list(range(41, 51)))

ds = Merger(testset(df1), testset(df2), batch_size=3)

loader = torch.utils.data.DataLoader(ds, shuffle=False, num_workers=0, batch_size=3)

for data in loader:
    print(data)
于 2021-07-13T09:22:17.557 回答