Neural network Pytorch中正确的数据加载、拆分和扩充

本教程似乎没有解释我们应该如何加载、拆分和进行适当的扩充

让我们有一个由汽车和猫组成的数据集。文件夹结构将是：

data
  cat
    0101.jpg
    0201.jpg
    ...
  dogs
    0101.jpg
    0201.jpg
    ...

首先，我通过datasets.ImageFolder函数加载数据集。图像函数有命令“TRANSFORM”，我们可以在其中设置一些增强命令，但我们不想将增强应用于测试数据集！因此，让我们继续使用transform=None

data = datasets.ImageFolder(root='data')

显然，我们没有文件夹结构训练和测试，因此我认为使用

现在让我们按照以下方式加载数据

    train_loader = torch.utils.data.DataLoader(train_dataset,
                                              batch_size=8,
                                              shuffle=True)
    test_loader = torch.utils.data.DataLoader(test_dataset,
                                              batch_size=8,
                                              shuffle=True)

如何将转换（数据增强）应用于“train_loader”图像

基本上我需要：1。从上面解释的文件夹结构加载数据 2.将数据拆分为测试/列车部分

---

3.在列车部件上应用增强

我不确定是否有推荐的方法来解决这个问题，但这就是我解决这个问题的方法：

鉴于

torch.utils.data.random_split（）

返回

子集

，我们不能（我们不能100%确定我在这里仔细检查过，我们不能）利用它们的内部数据集，因为它们是相同的（唯一的区别在于索引）。在这种情况下，我将实现一个简单的类来应用转换，如下所示：

来自torch.utils.data导入数据集的

类ApplyTransform（数据集）：
"""
将转换应用于数据集
论据：
数据集（dataset）：返回（样本、目标）的数据集
transform（可调用，可选）：应用于示例的函数/转换
target_transform（可调用，可选）：应用于目标的函数/转换
"""
def_uuuinit_uuuu（self，dataset，transform=None，target_utransform=None）：
self.dataset=dataset
self.transform=transform
self.target\u transform=target\u transform
#是的，您不需要以下两行：(
如果transform为None且target_transform为None：
打印（“我对你来说是个笑话吗？：））
def uu getitem uu（self，idx）：
sample，target=self.dataset[idx]
如果self.transform不是None：
示例=自转换（示例）
如果self.target_transform不是无：
目标=自我。目标\转换（目标）
返回样本、目标
定义（自我）：
返回len（self.dataset）

然后在将数据集传递给数据加载器之前使用它：

导入torchvision.transforms作为变换
train_transform=变换。组合([
transforms.ToTensor（），
# ...
])
训练数据集=应用转换（训练数据集，转换=训练转换）
#继续使用数据加载程序。。。

我想你可以看到这一点

def get\u train\u valid\u loader（数据目录、，
批量大小，
加强
随机种子，
有效_大小=0.1，
洗牌=正确，
show_sample=False，
工人数量=4，
引脚（内存=错误）：
"""
装载和返回列车的实用功能，有效
CIFAR-10数据集上的多进程迭代器。示例
可以选择显示9x9图像网格。
如果使用CUDA，num_workers应设置为1，pin_memory应设置为True。
Params
------
-data_dir：数据集的路径目录。
-批次大小：每批装载多少样品。
-扩充：是否应用数据扩充方案
文中提到。仅适用于列车拆分。
-随机种子：固定种子以获得重复性。
-有效大小：用于存储的训练集的百分比分割
验证集。应为[0,1]范围内的浮点。
-洗牌：是否洗牌训练/验证指标。
-显示样本：绘制数据集的9x9样本网格。
-num_workers：加载数据集时要使用的子进程数。
-pin_memory：是否将张量复制到CUDA固定内存中。将其设置为
如果使用GPU，则为True。
退换商品
-------
-训练加载程序：训练集迭代器。
-有效的\u加载程序：验证集迭代器。
"""
错误\u msg=“[！]有效\u大小应在[0，1]范围内
assert（（valid\u size>=0）和（valid\u size）我将试用。另一种方法是在模型之前使用拆分文件夹。
    train_loader = torch.utils.data.DataLoader(train_dataset,
                                              batch_size=8,
                                              shuffle=True)
    test_loader = torch.utils.data.DataLoader(test_dataset,
                                              batch_size=8,
                                              shuffle=True)

def get_train_valid_loader(data_dir,
                           batch_size,
                           augment,
                           random_seed,
                           valid_size=0.1,
                           shuffle=True,
                           show_sample=False,
                           num_workers=4,
                           pin_memory=False):
    """
    Utility function for loading and returning train and valid
    multi-process iterators over the CIFAR-10 dataset. A sample
    9x9 grid of the images can be optionally displayed.
    If using CUDA, num_workers should be set to 1 and pin_memory to True.
    Params
    ------
    - data_dir: path directory to the dataset.
    - batch_size: how many samples per batch to load.
    - augment: whether to apply the data augmentation scheme
      mentioned in the paper. Only applied on the train split.
    - random_seed: fix seed for reproducibility.
    - valid_size: percentage split of the training set used for
      the validation set. Should be a float in the range [0, 1].
    - shuffle: whether to shuffle the train/validation indices.
    - show_sample: plot 9x9 sample grid of the dataset.
    - num_workers: number of subprocesses to use when loading the dataset.
    - pin_memory: whether to copy tensors into CUDA pinned memory. Set it to
      True if using GPU.
    Returns
    -------
    - train_loader: training set iterator.
    - valid_loader: validation set iterator.
    """
    error_msg = "[!] valid_size should be in the range [0, 1]."
    assert ((valid_size >= 0) and (valid_size <= 1)), error_msg

    normalize = transforms.Normalize(
        mean=[0.4914, 0.4822, 0.4465],
        std=[0.2023, 0.1994, 0.2010],
    )

    # define transforms
    valid_transform = transforms.Compose([
            transforms.ToTensor(),
            normalize,
    ])
    if augment:
        train_transform = transforms.Compose([
            transforms.RandomCrop(32, padding=4),
            transforms.RandomHorizontalFlip(),
            transforms.ToTensor(),
            normalize,
        ])
    else:
        train_transform = transforms.Compose([
            transforms.ToTensor(),
            normalize,
        ])

    # load the dataset
    train_dataset = datasets.CIFAR10(
        root=data_dir, train=True,
        download=True, transform=train_transform,
    )

    valid_dataset = datasets.CIFAR10(
        root=data_dir, train=True,
        download=True, transform=valid_transform,
    )

    num_train = len(train_dataset)
    indices = list(range(num_train))
    split = int(np.floor(valid_size * num_train))

    if shuffle:
        np.random.seed(random_seed)
        np.random.shuffle(indices)

    train_idx, valid_idx = indices[split:], indices[:split]
    train_sampler = SubsetRandomSampler(train_idx)
    valid_sampler = SubsetRandomSampler(valid_idx)

    train_loader = torch.utils.data.DataLoader(
        train_dataset, batch_size=batch_size, sampler=train_sampler,
        num_workers=num_workers, pin_memory=pin_memory,
    )
    valid_loader = torch.utils.data.DataLoader(
        valid_dataset, batch_size=batch_size, sampler=valid_sampler,
        num_workers=num_workers, pin_memory=pin_memory,
    )

    # visualize some images
    if show_sample:
        sample_loader = torch.utils.data.DataLoader(
            train_dataset, batch_size=9, shuffle=shuffle,
            num_workers=num_workers, pin_memory=pin_memory,
        )
        data_iter = iter(sample_loader)
        images, labels = data_iter.next()
        X = images.numpy().transpose([0, 2, 3, 1])
        plot_images(X, labels)

    return (train_loader, valid_loader)