标签: dataloader

如何从 DataLoader 加载整个数据集？我只得到一批数据集。

这是我的代码

dataloader = torch.utils.data.DataLoader(dataset=dataset, batch_size=64)
images, labels = next(iter(dataloader))

我正在使用几个数据加载器，它们使用注入的查询服务（反过来又依赖于 DbContext）。它看起来像这样：

Field<ListGraphType<UserType>>(
  "Users",
  resolve: context =>
  {
    var loader = accessor.Context.GetOrAddBatchLoader<Guid, IEnumerable<User>>(
      "MyUserLoader",
      userQueryService.MyUserFunc);

    return loader.LoadAsync(context.Source.UserId);
  });

Field<ListGraphType<GroupType>>(
  "Groups",
  resolve: context =>
  {
    var loader = accessor.Context.GetOrAddBatchLoader<Guid, IEnumerable<Group>>(
      "MyGroupLoader",
      groupQueryService.MyGroupFunc);

    return loader.LoadAsync(context.Source.GroupId);
  });

当我运行同时使用两个数据加载器的嵌套查询时，出现异常 "A second operation started on this context before a previous asynchronous operation completed"因为两个数据加载器同时使用相同的 DbContext。

在查询中允许并发数据库访问而不必仔细管理 DbContexts 的最佳方法是什么ServiceLifeTime.Transient？或者数据加载器是否可以公开一种方法来知道何时处理瞬态 DbContext？

我正在尝试实施某种基本的社交网络项目。它有Posts，Comments并且Likes像其他任何一样。

• 一个帖子可以有很多评论
• 一个帖子可以有很多人点赞
• 一篇文章可以有一个作者

我/posts在客户端应用程序上有一条路线。它按分页列出Posts并显示它们的title、image、authorName和。commentCountlikesCount

查询graphql是这样的；

query {
  posts(first: 10, after: "123456") {
    totalCount
    edges {
      node {
        id
        title
        imageUrl
        author {
          id
          username
        }
        comments {
          totalCount
        }
        likes {
          totalCount
        }
      }
    }
  }
}

我正在使用apollo-server、TypeORM和PostgreSQL。dataloader我用来dataloader获取author每个帖子。authorIds我只是用批处理请求dataloader，authors从PostgreSQL查询中获取where …

我正在尝试在 Pytorch 中运行以下代码：

import numpy as np
import torch
import torchvision
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data as data


class H5Dataset(data.Dataset):

    def __init__(self, trainx_path, trainy_path):

        super(H5Dataset, self).__init__()
        x_file = h5py.File(trainx_path)
        y_file = h5py.File(trainy_path)

        self.data = x_file.get('X')        
        self.target = y_file.get('y')

    def __getitem__(self, size):

      permutation1 = list(np.random.permutation(249000))  
      permutation2 = list(np.random.permutation(np.arange(249000,498000)))

      size1 = int(size/2)
      index1=list(permutation1[0:size1])
      index2=list(permutation2[0:size1])
      index = index1+index2
      labels=np.array(self.target).reshape(498000,-1)
      train_labels=labels[index]
      train_batch=[]

      for i in range(size):
          img=(self.data)[index[i]]
          train_batch.append(img)    
      train_batch=np.array(train_batch)

      return (torch.from_numpy(train_batch).float(), torch.from_numpy(train_labels).float())


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


dataset = H5Dataset('//content//drive//My …

我正在尝试使用以下代码初始化 DataLoader 的实例：

const authorLoader = new DataLoader(async (keys:string[]) => {
    // Return an author for each book
});

我收到以下错误：

Argument of type '(keys: string[]) => Promise<Author[]>' is not assignable to parameter of type 'BatchLoadFn<string, Author>'.
Types of parameters 'keys' and 'keys' are incompatible.
The type 'readonly string[]' is 'readonly' and cannot be assigned to the mutable type 'string[]'

为什么我会收到此错误以及如何修复它？我阅读了Generics数据加载器的源代码，但尚未找到解决方案。

注意：keys是 类型string[]，而不是number[]因为我使用的是uuid's。

我正在处理一个太大而无法放入 RAM 的数据集。我目前正在尝试的解决方案是使用 numpy memmap 使用 Dataloader 一次加载一个样本/行。解决方案看起来像这样：

class MMDataset(torch.utils.data.Dataset):
    def __init__(self, path):
        self.file_path = path
        self.dataset_len = 44000000
        self.bytes_per_value = 32/8
        self.num_cols = 512
        self.num_rows = 1


    def __getitem__(self, index):


        x = np.memmap(self.file_path, dtype='float32', mode='r', shape=(
            self.num_rows, self.num_cols), offset=int(index*self.num_cols*self.bytes_per_value))

        return np.array(x)

    def __len__(self):
        return self.dataset_len



dataset = MMDataset('./data/emb.memmap')

data_loader = DataLoader(
    dataset,
    batch_size=4096,
    shuffle=True,
    num_workers=20
)

当可用RAM量大于memmap文件的大小时，数据加载速度很快。我每秒处理大约60 批。但是，当可用 RAM 小于 memmap 文件的大小时，我得到大约 3 个批次/秒。

我在尝试不同大小的 memmap 文件时发现了这一点。

为什么会这样呢？如果当可用 RAM < memmap 文件大小时 Dataloader …

我有一个 GraphQL API，可以使用传统的解析函数正常工作。我的目标是消除N+1问题。

为此，我决定使用数据加载器。我已经完成了这些步骤以使应用程序运行：

1. 我将这两个函数添加到我的上下文模块中：

defmodule Project.People do
  # CRUD...

  def data, do: Dataloader.Ecto.new(Repo, query: &query/2)

  def query(queryable, _params) do
    queryable
  end
end

2. 我将context/1和添加plugins/0到架构模块并更新了查询解析器：

defmodule ProjectWeb.GraphQL.Schema do
  use Absinthe.Schema

  import Absinthe.Resolution.Helpers, only: [dataloader: 1]

  alias ProjectWeb.GraphQL.Schema
  alias Project.People

  import_types(Schema.Types)

  query do
    @desc "Get a list of all people."
    field :people, list_of(:person) do
      resolve(dataloader(People))
    end

    # Other queries...
  end

  def context(context) do
    loader =
      Dataloader.new()
      |> Dataloader.add_source(People, People.data())

    Map.put(context, :loader, loader)
  end

  def plugins, do: [Absinthe.Middleware.Dataloader | …

我正在使用 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, …

我正在尝试使用3 个输入、3 个input_masks 和一个标签作为我的训练数据集的张量来训练一个预训练的 roberta 模型。

我使用以下代码执行此操作：

from torch.utils.data import TensorDataset, DataLoader, RandomSampler, SequentialSampler
batch_size = 32
# Create the DataLoader for our training set.
train_data = TensorDataset(train_AT, train_BT, train_CT, train_maskAT, train_maskBT, train_maskCT, labels_trainT)
train_dataloader = DataLoader(train_data, batch_size=batch_size)

# Create the Dataloader for our validation set.
validation_data = TensorDataset(val_AT, val_BT, val_CT, val_maskAT, val_maskBT, val_maskCT, labels_valT)
val_dataloader = DataLoader(validation_data, batch_size=batch_size)

# Pytorch Training
training_args = TrainingArguments(
    output_dir='C:/Users/samvd/Documents/Master/AppliedMachineLearning/FinalProject/results',          # output directory
    num_train_epochs=1,              # total # of training epochs …

在 Pytorch 1.4 中使用自定义数据集训练模型时，在看似随机的时期后会引发以下错误。

RuntimeError: Couldn't open shared file mapping: <torch_15324_2327643205>, error code: <1455>

数据集被包装在 a 中torch.utils.data.DataLoader并使用 4 个工作线程，等于物理核心的数量。

class TSNDataSet(data.Dataset):
    def __init__(self, pickle_file_paths, transforms):
        self.pickle_file_paths = pickle_file_paths # list with file paths to pickle files
        self.dataset_size = len(pickle_file_paths)

    def __getitem__(self, index):
        with open(self.pickle_file_paths[index], 'rb') as f:
            mffs = pickle.load(f)
            
        return mffs, index

    def __len__(self):
        return self.dataset_size

了解错误的含义以及可能的解决方案是什么会很有帮助。