Как я могу использовать Pytorch DataLoader для вывода небольших 2D-блоков большей 2D-сетки значений x и y?

Question

Я пытаюсь вывести «порции» значений x и y, которые являются меньшими частями большей сетки.

Так, например, я хочу, чтобы первая партия имела значения x от 0 до 250 иу значения от 0 до 250.Тогда следующая партия будет х = 0-250 и у = 250-500.Другая партия будет х = 250-500 и у = 250-500.И наконец, x = 250-500 и y = 0-250.

Таким образом, каждый вызов для захвата пакета с помощью класса DataLoader будет захватывать небольшой 2D-блок большей 2D-сетки.

Это то, что у меня есть до сих пор ..

class inputDataset(Dataset):

  def __init__(self):
    self.z = 
    torch.Tensor([0.234,0.123,0.831,0.456,0.910,0.356,0.276,0.081])
    self.xmax = 1000
    self.xmin = 0
    self.ymax = 1000
    self.ymin = 0

    self.x = torch.linspace(self.xmin,self.xmax-1,self.xmax)
    self.y = torch.linspace(self.ymin,self.ymax-1,self.ymax)
    self.r = torch.sqrt(torch.mul(self.x,self.x) + /
    torch.mul(self.y,self.y))


  def __len__(self):
    return self.xmax**2 *  (len(self.z) + 3)

  def __getitem__(self, idx):

    out = /
    torch.cat((torch.cat((self.z,self.x[idx].unsqueeze(dim=0)/
    )),torch.cat((self.y[idx].unsqueeze(dim=0)/
    ,self.r[idx].unsqueeze(dim=0)))))

    return out

Прямо сейчас я могу получить x и y для вывода, но они одинаковые числа, а не куски.

Answer 1

Вот что я придумала до сих пор ...

class GridDataset:
    def __init__(self):
        self.chunk_size = 5

        self.x = torch.arange(100)
        self.y = torch.arange(100)
        self.z = torch.tensor([0.22,0.22,0.45,0.788,0.013])

    def chunks_x(self):
        return self.x.size(0) // self.chunk_size

    def chunks_y(self):
        return self.y.size(0) // self.chunk_size

    def __len__(self):
        return self.chunks_x() * self.chunks_y()

    def __getitem__(self, idx):
        if idx >= len(self): raise IndexError()
        # integer division to get the id along the first axis
        x_idx = idx // self.chunks_x()
        # modulo division to get the id along the other axis
        y_idx = idx % self.chunks_x()

        cs = self.chunk_size # to make lines shorter

        # grab the actual slices using the computed values of x_idx and y_idx
        x_chunk = self.x[cs * x_idx:cs * (1+x_idx)]
        y_chunk = self.y[cs * y_idx:cs * (1+y_idx)]
        print(x_chunk.shape)

        x_chunk = x_chunk.unsqueeze(dim=1).double()
        y_chunk = y_chunk.unsqueeze(dim=1).double()

        xytotal = torch.cat((x_chunk,y_chunk),dim=1)
        r = torch.sqrt(x_chunk**2 + y_chunk**2).float()
        new = torch.zeros((len(xytotal),len(xytotal[0]) + len(self.z)))
        for i in range(len(xytotal)):
          new[i] = torch.cat((xytotal[i].double(),self.z.double()))
        new = torch.cat((new,r),dim=1)


        return new

Если я отображаю одно значение, оно выдает:

torch.Size([5])
tensor([[0.0000, 5.0000, 0.2200, 0.2200, 0.4500, 0.7880, 0.0130, 5.0000],
        [1.0000, 6.0000, 0.2200, 0.2200, 0.4500, 0.7880, 0.0130, 6.0828],
        [2.0000, 7.0000, 0.2200, 0.2200, 0.4500, 0.7880, 0.0130, 7.2801],
        [3.0000, 8.0000, 0.2200, 0.2200, 0.4500, 0.7880, 0.0130, 8.5440],
        [4.0000, 9.0000, 0.2200, 0.2200, 0.4500, 0.7880, 0.0130, 9.8489]])

Answer 2

Я позволил себе удалить большинство посторонних частей вашего кода, таких как z и r.Минимальный загрузчик данных, который возвращает последовательные области 2-мерной сетки, как вы ее определили, ниже

import torch

class GridDataset:
    def __init__(self):
        self.chunk_size = 250

        self.x = torch.arange(500)
        self.y = torch.arange(500)

    def chunks_x(self):
        return self.x.size(0) // self.chunk_size

    def chunks_y(self):
        return self.y.size(0) // self.chunk_size

    def __len__(self):
        return self.chunks_x() * self.chunks_y()

    def __getitem__(self, idx):
        # integer division to get the id along the first axis
        x_idx = idx // self.chunks_x()
        # modulo division to get the id along the other axis
        y_idx = idx % self.chunks_x()

        cs = self.chunk_size # to make lines shorter

        # grab the actual slices using the computed values of x_idx and y_idx
        x_chunk = self.x[cs * x_idx:cs * (1+x_idx)]
        y_chunk = self.y[cs * y_idx:cs * (1+y_idx)]

        return x_chunk, y_chunk

Обратите внимание, что я не совсем понимаю цель объединения в вашей __getitem__ - я просто возвращаюдва тензора с кусками от x и y.Пожалуйста, дайте мне знать, если этот подход решит вашу проблему.