标签: dataloader

dataloader如何在密钥中缓存和批量请求和存储.

https://github.com/facebook/dataloader

在这里,我需要dataloader包并创建一个实例,但它如何工作aby想法................................. ..请查询数据库查询,为db查找表提供示例

var DataLoader = require('dataloader')

var userLoader = new DataLoader(keys => myBatchGetUsers(keys));

userLoader.load(1)
    .then(user => userLoader.load(user.invitedByID))
    .then(invitedBy => console.log(`User 1 was invited by ${invitedBy}`));

// Elsewhere in your application
userLoader.load(2)
    .then(user => userLoader.load(user.lastInvitedID))
    .then(lastInvited => console.log(`User 2 last invited ${lastInvited}`));

我已经建立了一个数据集，我正在对我正在加载的图像进行各种检查。然后我将此 DataSet 传递给 DataLoader。

在我的 DataSet 类中，如果图片未通过我的检查，我将样本作为 None 返回，并且我有一个自定义 collat​​e_fn 函数，该函数从检索到的批次中删除所有 None 并返回剩余的有效样本。

然而，此时返回的批次可能具有不同的大小。有没有办法告诉 collat​​e_fn 继续获取数据，直到批量大小达到一定长度？

class DataSet():
     def __init__(self, example):
          # initialise dataset
          # load csv file and image directory
          self.example = example
     def __getitem__(self,idx):
          # load one sample
          # if image is too dark return None
          # else 
          # return one image and its equivalent label

dataset = Dataset(csv_file='../', image_dir='../../')

dataloader = DataLoader(dataset , batch_size=4,
                        shuffle=True, num_workers=1, collate_fn = my_collate )

def my_collate(batch): # batch size 4 [{tensor …

我正在尝试在 PyTorch 中建立一个通用的强化学习框架，以利用所有利用 PyTorch DataSet 和 DataLoader 的高级实用程序，例如 Ignite 或 FastAI，但我遇到了动态特性的阻碍强化学习数据：

• 数据项是从代码生成的，而不是从文件读取，并且它们依赖于先前的操作和模型结果，因此每个 nextItem 调用都需要访问模型状态。
• 训练集的长度不固定，因此我需要动态批量大小以及动态总数据集大小。我的偏好是使用终止条件函数而不是数字。我“可能”可以通过填充来做到这一点，就像在 NLP 句子处理中一样，但这是一个真正的黑客。

到目前为止，我的 Google 和 StackOverflow 搜索结果毫无结果。这里有人知道使用 DataLoader 或 DataSet 进行强化学习的现有解决方案或解决方法吗？我讨厌失去对依赖于这些库的所有现有库的访问权限。

我正在使用 Densenet121 从 Kaggle 数据集进行猫/狗检测。我启用了 cuda，看起来训练速度非常快。但是，数据加载（或可能处理）似乎很慢。有什么方法可以加快速度吗？我尝试玩女巫批量大小，但没有提供太多帮助。我还将 num_workers 从 0 更改为一些正数。从 0 到 2 将加载时间减少了 1/3，增加更多不会产生额外的效果。还有其他方法可以加快加载速度吗？

这是我的粗略代码（我专注于学习，所以它不是很有条理）：

import matplotlib.pyplot as plt

import torch
from torch import nn
from torch import optim
import torch.nn.functional as F
from torchvision import datasets, transforms, models

data_dir = 'Cat_Dog_data'

train_transforms = transforms.Compose([transforms.RandomRotation(30),
                                       transforms.RandomResizedCrop(224),
                                       transforms.RandomHorizontalFlip(),
                                       transforms.ToTensor(),
                                       transforms.Normalize([0.5, 0.5, 0.5],
                                                            [0.5, 0.5, 0.5])])
test_transforms = transforms.Compose([transforms.Resize(255),
                                      transforms.CenterCrop(224),
                                      transforms.ToTensor()])

# Pass transforms in here, then run the next cell to see how the transforms look
train_data = datasets.ImageFolder(data_dir + …

我需要BatchSampler在 pytorch 中使用 a DataLoader，而不是__getitem__多次调用数据集（远程数据集，每个查询都很昂贵）。
我无法理解如何将批量采样器与任何给定的数据集一起使用。

例如

class MyDataset(Dataset):

    def __init__(self, remote_ddf, ):
        self.ddf = remote_ddf

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

    def __getitem__(self, idx):
        return self.ddf[idx] --------> This is as expensive as a batch call

    def get_batch(self, batch_idx):
        return self.ddf[batch_idx]

my_loader = DataLoader(MyDataset(remote_ddf), 
           batch_sampler=BatchSampler(Sampler(), batch_size=3))

我不明白的是，在网上或火炬文档中都没有找到任何示例，我不明白的是如何使用我的get_batch函数而不是 __getitem__ 函数。
编辑：根据 Szymon Maszke 的回答，这就是我尝试过的，但\_\_get_item__每次调用都会获取一个索引，而不是大小列表batch_size

class Dataset(Dataset):

    def __init__(self):
       ...

    def __len__(self):
        ...

    def __getitem__(self, batch_idx):  ------> here I get only one …

我试图找出使用 type-graphql 和 typeorm 和 postgresql db（使用 apollo 服务器和 express）处理一对多关系的最佳方法。我有一个与课程表具有一对多关系的用户表。我目前处理此问题的方法是使用 @RelationId 字段创建一列 userCourseIds，然后使用 @FieldResolver 和 dataloader 批量获取属于该用户的课程。我的问题是，对于 @RelationId 字段，无论我是否实际查询 userCourses，都会进行一个单独的查询来获取关系 ID。有没有办法解决这个问题，它不会进行额外的查询，或者有没有更好的方法来处理一对多关系？

关系的用户端：

@OneToMany(() => Course, (course) => course.creator, { cascade: true })
userCourses: Course[];
@RelationId((user: User) => user.userCourses)
userCourseIds: string;

关系的课程方面：

@Field()
@Column()
creatorId: string;

@ManyToOne(() => User, (user) => user.userCourses)
creator: User;

用户课程字段解析器：

@FieldResolver(() => [Course], { nullable: true })
async userCourses(@Root() user: User, @Ctx() { courseLoader }: MyContext) {
  const userCourses = await courseLoader.loadMany(user.userCourseIds);
  return userCourses;
}

我有以下代码：

# Device configuration
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
seed = 42
np.random.seed(seed)
torch.manual_seed(seed)

# split the dataset into validation and test sets
len_valid_set = int(0.1*len(dataset))
len_train_set = len(dataset) - len_valid_set

print("The length of Train set is {}".format(len_train_set))
print("The length of Test set is {}".format(len_valid_set))

train_dataset , valid_dataset,  = torch.utils.data.random_split(dataset , [len_train_set, len_valid_set])

# shuffle and batch the datasets
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=8, shuffle=True, num_workers=4)
test_loader = torch.utils.data.DataLoader(valid_dataset, batch_size=8, shuffle=True, num_workers=4)

print("LOADERS",
    len(dataloader),
    len(train_loader),
    len(test_loader))

火车组的长度是720

测试集的长度为80

装载机 …

我正在研究 NLP 问题并使用 PyTorch。由于某种原因，我的数据加载器返回格式错误的批次。我的输入数据包含句子和整数标签。这些句子可以是句子列表或标记列表列表。稍后我将在下游组件中将标记转换为整数。

list_labels = [ 0, 1, 0]

# List of sentences.
list_sentences = [ 'the movie is terrible',
                   'The Film was great.',
                   'It was just awful.']

# Or list of list of tokens.
list_sentences = [['the', 'movie', 'is', 'terrible'],
                  ['The', 'Film', 'was', 'great.'],
                  ['It', 'was', 'just', 'awful.']]

我创建了以下自定义数据集：

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

class MyDataset(torch.utils.data.Dataset):

    def __init__(self, sentences, labels):

        self.sentences = sentences
        self.labels = labels

    def __getitem__(self, i):
        result = {}
        result['sentences'] = …

有几个场景让我对改组数据加载器感到困惑，如下所示。

我在 train_loader 和 valid_loader 上都将“shuffle”参数设置为 False。那么我得到的结果如下

Epoch 1/4    loss=0.8802     val_loss=0.8202     train_acc=0.63      val_acc=0.63  
Epoch 2/4    loss=0.6993     val_loss=0.6500     train_acc=0.66      val_acc=0.72 
Epoch 3/4    loss=0.5363     val_loss=0.5385     train_acc=0.76      val_acc=0.80
Epoch 4/4    loss=0.4055     val_loss=0.5130     train_acc=0.85      val_acc=0.81

我将 train_loader 上的“shuffle”参数设置为 True，并将 False 设置为 valid_loader。那么我得到的结果如下

Epoch 1/4    loss=0.8928     val_loss=0.8284     train_acc=0.63      val_acc=0.63 
Epoch 2/4    loss=0.7308     val_loss=0.6263     train_acc=0.61      val_acc=0.73 
Epoch 3/4    loss=0.5594     val_loss=0.5046     train_acc=0.54      val_acc=0.81 
Epoch 4/4    loss=0.4304     val_loss=0.4525     train_acc=0.49      val_acc=0.82 

基于该结果，当我对 train_loader 进行 shuffle 时，我的训练准确度的性能更差。

这是我的代码片段。

Epoch 1/4    loss=0.8802     val_loss=0.8202     train_acc=0.63      val_acc=0.63  
Epoch 2/4    loss=0.6993     val_loss=0.6500     train_acc=0.66      val_acc=0.72 …

PyTorch/Numpy 中存在一个错误，即当与 a DataLoader（即设置num_workers > 1）并行加载批次时，每个工作线程使用相同的 NumPy 随机种子，导致并行批次之间应用的任何随机函数都是相同的。

最小的例子：

import numpy as np
from torch.utils.data import Dataset, DataLoader

class RandomDataset(Dataset):
    def __getitem__(self, index):
        return np.random.randint(0, 1000, 2)

    def __len__(self):
        return 9
    
dataset = RandomDataset()
dataloader = DataLoader(dataset, batch_size=1, num_workers=3)

for batch in dataloader:
    print(batch)

如您所见，对于每个并行批次集 (3)，结果是相同的：

# First 3 batches
tensor([[891, 674]])
tensor([[891, 674]])
tensor([[891, 674]])
# Second 3 batches
tensor([[545, 977]])
tensor([[545, 977]])
tensor([[545, 977]])
# Third 3 batches
tensor([[880, 688]])
tensor([[880, 688]])
tensor([[880, …