小编anu*_*rag的帖子

Dataset如果我们使用和类的组合Dataloader（如下所示），我必须使用或显式地将数据加载到GPU上。有没有办法指示数据加载器自动/隐式执行此操作？.to().cuda()

理解/重现场景的代码：

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

class DemoData(Dataset):
    def __init__(self, limit):
        super(DemoData, self).__init__()
        self.data = np.arange(limit)

    def __len__(self):
        return self.data.shape[0]

    def __getitem__(self, idx):
        return (self.data[idx], self.data[idx]*100)

demo = DemoData(100)

loader = DataLoader(demo, batch_size=50, shuffle=True)

for i, (i1, i2) in enumerate(loader):
    print('Batch Index: {}'.format(i))
    print('Shape of data item 1: {}; shape of data item 2: {}'.format(i1.shape, i2.shape))
    # i1, i2 = i1.to('cuda:0'), i2.to('cuda:0')
    print('Device of data item 1: {}; …

我有以下场景 - 考虑如下的字典列表（输入）：

data = [{'key1' : 'k1v1', 'key2': 'k2v1'}, {'key1': 'k1v2', 'key2': 'k2v2'}, 
{'key1': 'k1v3', 'key2': 'k2v3'}, {'key1': 'k1v4', 'key2': 'k2v4'}]

可以看出，字典中的键是相同的。所以我想要做的是以下（期望的输出）：

{'key1': ['k1v1', 'k1v2', 'k1v3', 'k1v4'], 'key2': ['k2v1', 'k2v2', 'k2v3', 'k2v4']}

为了实现这一点，我可以使用以下简单的直接嵌套循环：

data_dict = dict()
for d in data:
    for k, v in d.items():
        if k in data_dict:
            data_dict[k].append(v)
        else:
            data_dict[k] = [v]

问题：我们可以使用字典理解来做到这一点吗？换句话说，我们可以在字典理解中附加到现有的值列表吗？

给出以下代码：

class DTC:
    def __init__(self):
        self.__root = None

    def unique(self,Y):
        d = {}
        for i in Y:
            if i not in d:
                d[i]=1
            else:
                d[i]+=1
        return d

    def ent(self,Y):
        freq = self.__count_unique(Y)
        ent_ = 0
        total = len(Y)
        for i in freq:
            p = freq[i]/total
            entropy_ += (-p)*math.log2(p)
        return ent_

如果将其放置在 Jupyter Notebook 的单个单元格中，则上面的代码将会运行。但是，如果我希望将类代码拆分为多个单元格，如下所示，如何才能使类代码工作：

细胞1

class DTC:
    def __init__(self):
        self.__root = None

细胞2

    def unique(self,Y):
        d = {}
        for i in Y:
            if i not in d:
                d[i]=1
            else:
                d[i]+=1 …

我遇到了一个用于torch.einsum计算张量乘法的代码。我能够理解低阶张量的工作原理，但是不能理解 4D 张量的工作原理，如下所示：

import torch

a = torch.rand((3, 5, 2, 10))
b = torch.rand((3, 4, 2, 10))

c = torch.einsum('nxhd,nyhd->nhxy', [a,b])

print(c.size())

# output: torch.Size([3, 2, 5, 4])

我需要以下方面的帮助：

1. 这里执行的操作是什么（解释矩阵如何相乘/转置等）？
2. torch.einsum在这种情况下实际上有好处吗？