标签: dataloader

在训练循环中，我将一批数据加载到 CPU 中，然后将其传输到 GPU：

import torch.utils as utils

train_loader = utils.data.DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=4, pin_memory=True)

for inputs, labels in train_loader:
    inputs, labels = inputs.to(device), labels.to(device)

这种加载数据的方式非常耗时。有什么方法可以直接将数据加载到 GPU 中而不需要传输步骤吗？

有没有办法将 pytorch DataLoader ( torch.utils.data.Dataloader) 完全加载到我的 GPU 中？

现在，我将每个批次分别加载到我的 GPU 中。

CTX = torch.device('cuda')

train_loader = torch.utils.data.DataLoader(
    train_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,
    num_workers=0,
)

net = Net().to(CTX)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=LEARNING_RATE)

for epoch in range(EPOCHS):
    for inputs, labels in test_loader:
        inputs = inputs.to(CTX)        # this is where the data is loaded into GPU
        labels = labels.to(CTX)        

        optimizer.zero_grad()

        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

    print(f'training accuracy: {net.validate(train_loader, device=CTX)}/{len(train_dataset)}')
    print(f'validation accuracy: {net.validate(test_loader, device=CTX)}/{len(test_dataset)}')

其中Net.validate()函数由下式给出

def …

当我创建一个 PyTorch DataLoader 并开始迭代时——我得到了一个非常慢的第一个纪元（x10--x30 比所有下一个纪元都慢）。此外，此问题仅出现在来自 Kaggle 的 Google 地标识别 2020 的训练数据集上。我无法在合成图像上重现此内容，此外，我尝试创建一个包含来自 GLR2020 的 500k 图像的文件夹，并且一切正常。在PyTorch论坛中发现了几个类似的问题，没有任何解决办法。

import argparse
import pandas as pd
import numpy as np
import os, sys
import multiprocessing, ray
import time
import cv2
import logging
import albumentations as albu
from torch.utils.data import Dataset, DataLoader

samples = 50000 # count of samples to speed up test
bs = 64 # batch size
dir = '/hdd0/datasets/ggl_landmark_recognition_2020/train' # directory with train data
all_files = pd.read_csv('/hdd0/datasets/ggl_landmark_recognition_2020/train.csv')
files = np.random.choice(all_files.id.values, 50000)
files = …

我目前正在尝试使用 PyTorch 的 DataLoader 处理数据以输入我的深度学习模型，但遇到了一些困难。

我需要的数据是 shape (minibatch_size=32, rows=100, columns=41)。该__getitem__COAD，我有自定义的内Dataset类，我写了看起来是这样的：

def __getitem__(self, idx):
    x = np.array(self.train.iloc[idx:100, :])
    return x

我这样写的原因是因为我希望 DataLoader 一次处理形状的输入实例(100, 41)，而我们有 32 个这样的单个实例。

但是，我注意到与我最初的看法相反，idxDataLoader 传递给函数的参数不是顺序的（这很重要，因为我的数据是时间序列数据）。例如，打印值给了我这样的东西：

idx = 206000
idx = 113814
idx = 80597
idx = 3836
idx = 156187
idx = 54990
idx = 8694
idx = 190555
idx = 84418
idx = 161773
idx = 177725
idx = 178351
idx = 89217
idx = 11048
idx = …

我有一个非常普通的GraphQL模式，如下所示（伪代码）：

Post {
  commentsPage(skip: Int, limit: Int) {
    total: Int
    items: [Comment]
  }
}

因此，为避免在请求多个Post对象时出现n + 1问题，我决定使用Facebook的Dataloader。

由于我正在使用Nest.JS 3层分层应用程序（Resolver-Service-Repository），因此我有一个问题：

应该使用DataLoader包装存储库方法还是应该使用Dataloder包装服务方法？

下面是我的返回Comments页面的服务方法的示例（即，从commentsPage属性解析器调用的此方法）。内部服务方法中，我使用2个存储库方法（#count 和#find）：

@Injectable()
export class CommentsService {
    constructor(
        private readonly repository: CommentsRepository,
    ) {}

    async getCommentsPage(postId, dataStart, dateEnd, skip, limit): PaginatedComments {
        const counts = await this.repository.getCount(postId, dateStart, dateEnd);
        const itemsDocs = await this.repository.find(postId, dateStart, dateEnd, skip, limit);
        const items = this.mapDbResultToGraphQlType(itemsDocs);
        return new PaginatedComments(total, items)
    }
}

因此，我应该为每个存储库方法（#count， …

在我的 Flutter 项目中，我正在执行 API 调用以通过 GET 请求获取数据。从响应解析JSON 对象后，我只在Text小部件中显示值。虽然加载数据需要时间，但同时我的 Text 小部件显示为空。

对于 API 调用部分，我有以下代码-

class Webservice {
  Future<T> load<T>(Resource<T> resource) async {
    var jwt = await LocalStore().getJWT();
    print(jwt);

    final response = await http.get(resource.url,
        headers: {
          'Content-Type': 'application/json',
          'token': '${Constants.TOKEN}',
          'jwt': '$jwt',
        }
    );
    if(response.statusCode == 200) {
      print('${response.body}');
      return resource.parse(response);
    } else {
      throw Exception('Failed to load data!');
    }
  }
}

我为 JSON 解析创建了一个Model 类-

class Category {
  int catNote;
  int catTodo;
  int catRem;
  int catTag; …

问题是关于PyTorch 网站上的数据加载教程。我不知道他们是怎么写的价值mean_pix和std_pix的在transforms.Normalize不用计算

我无法在 StackOverflow 上找到与此问题相关的任何解释。

import torch
from torchvision import transforms, datasets

data_transform = transforms.Compose([
        transforms.RandomSizedCrop(224),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406],
                             std=[0.229, 0.224, 0.225])
    ])
hymenoptera_dataset = datasets.ImageFolder(root='hymenoptera_data/train',
                                           transform=data_transform)
dataset_loader = torch.utils.data.DataLoader(hymenoptera_dataset,
                                             batch_size=4, shuffle=True,
                                             num_workers=4)

价值mean=[0.485,0.456, 0.406]和std=[0.229, 0.224, 0.225]对我来说并不明显。他们如何得到它们？为什么他们等于这些？

我正在尝试使用 PyTorch 制作一个简单的图像分类器。这是我将数据加载到数据集和 dataLoader 中的方式：

batch_size = 64
validation_split = 0.2
data_dir = PROJECT_PATH+"/categorized_products"
transform = transforms.Compose([transforms.Grayscale(), CustomToTensor()])

dataset = ImageFolder(data_dir, transform=transform)

indices = list(range(len(dataset)))

train_indices = indices[:int(len(indices)*0.8)] 
test_indices = indices[int(len(indices)*0.8):]

train_sampler = SubsetRandomSampler(train_indices)
test_sampler = SubsetRandomSampler(test_indices)

train_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, sampler=train_sampler, num_workers=16)
test_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, sampler=test_sampler, num_workers=16)

我想分别打印出训练和测试数据中每个班级的图像数量，如下所示：

在火车数据中：

• 鞋子：20
• 衬衫：14

在测试数据中：

• 鞋子：4
• 衬衫：3

我试过这个：

from collections import Counter
print(dict(Counter(sample_tup[1] for sample_tup in dataset.imgs)))

但我收到了这个错误：

AttributeError: 'MyDataset' object has no attribute 'img'

我有以下代码：

import torch
import numpy as np
import pandas as pd
from torch.utils.data import TensorDataset, DataLoader

# Load dataset
df = pd.read_csv(r'../iris.csv')

# Extract features and target
data = df.drop('target',axis=1).values
labels = df['target'].values

# Create tensor dataset
iris = TensorDataset(torch.FloatTensor(data),torch.LongTensor(labels))

# Create random batches
iris_loader = DataLoader(iris, batch_size=105, shuffle=True)

next(iter(iris_loader))

上面的代码做了什么next()和iter()做什么？我已经阅读了PyTorch 的文档，但仍然可以完全理解这里是什么next()和iter()做什么。谁能帮忙解释一下？提前谢谢了。

使用 React-Router V6，我尝试强类型化正在使用的数据加载器函数params以及useLoaderData钩子。

到目前为止，我必须做以下难看的事情：

A- 对于useLoaderData，需要强制 returnType ：

const profil = useLoaderData() as TProfil;

export declare function useLoaderData<T>(): T;我想创建一个通用的钩子而不是导出会更干净declare function useLoaderData(): unknown;

B-对于数据加载器，接收到的参数的类型是什么？不得不强迫any，但这太丑了。如何强类型化并在某处声明 params 由来自路由定义中的参数名称的“id”组成？

const careerDetailDataLoader = async ({ params }: any): Promise<TProfil> => {
  const { id } = params;
  const res = await fetch(`http://localhost:4000/careers/${id}`);

  const data: TProfil = await res.json();
  return data;
};

<Route path=":id" element={<CareerDetailsPage />} loader={careerDetailDataLoader} />