PyTorch - смежные ()

Я просматривал этот пример языковой модели LSTM на github (ссылка) . Что он делает в целом, мне довольно ясно. Но я все еще пытаюсь понять, что contiguous()делает вызов , что происходит несколько раз в коде.

Например, в строке 74/75 создаются последовательности ввода кода и цели LSTM. Данные (хранящиеся в ids) являются двухмерными, где первое измерение - это размер пакета.

for i in range(0, ids.size(1) - seq_length, seq_length):
    # Get batch inputs and targets
    inputs = Variable(ids[:, i:i+seq_length])
    targets = Variable(ids[:, (i+1):(i+1)+seq_length].contiguous())

Итак, простой пример, при использовании размера партии 1 и seq_length10 inputsи targetsвыглядит так:

inputs Variable containing:
0     1     2     3     4     5     6     7     8     9
[torch.LongTensor of size 1x10]

targets Variable containing:
1     2     3     4     5     6     7     8     9    10
[torch.LongTensor of size 1x10]

В общем, у меня вопрос, что contiguous()и зачем мне это нужно?

Кроме того, я не понимаю, почему метод вызывается для целевой последовательности, а не для входной последовательности, поскольку обе переменные состоят из одних и тех же данных.

Как может targetsбыть неразрывным и inputsвсе же непрерывным?

РЕДАКТИРОВАТЬ: я попытался не использовать вызов contiguous(), но это привело к сообщению об ошибке при вычислении потерь.

RuntimeError: invalid argument 1: input is not contiguous at .../src/torch/lib/TH/generic/THTensor.c:231

Очевидно, что вызов contiguous()в этом примере необходим.

(Чтобы сохранить читабельность, я не публиковал здесь полный код, его можно найти, используя ссылку GitHub выше.)

Заранее спасибо!

В PyTorch есть несколько операций с Tensor, которые на самом деле не изменяют содержимое тензора, а только то, как преобразовать индексы в тензор в расположение байтов. Эти операции включают:

narrow(), view(), expand()Иtranspose()

Например: когда вы вызываете transpose(), PyTorch не генерирует новый тензор с новым макетом, он просто изменяет метаинформацию в объекте Tensor, поэтому смещение и шаг предназначены для новой формы. Транспонированный тензор и исходный тензор действительно разделяют память!

x = torch.randn(3,2)
y = torch.transpose(x, 0, 1)
x[0, 0] = 42
print(y[0,0])
# prints 42

Здесь на помощь приходит концепция непрерывности . Вышеупомянутое xявляется смежным, но yне потому, что его структура памяти отличается от тензора той же формы, созданного с нуля. Обратите внимание, что слово «смежный» немного вводит в заблуждение, потому что это не значит, что содержимое тензора распределено по отключенным блокам памяти. Здесь байты по-прежнему выделяются в одном блоке памяти, но порядок элементов другой!

Когда вы вызываете contiguous(), он фактически создает копию тензора, поэтому порядок элементов будет таким же, как если бы тензор той же формы был создан с нуля.

Обычно об этом не нужно беспокоиться. Если PyTorch ожидает непрерывный тензор, но если его нет, вы получите, RuntimeError: input is not contiguousа затем вы просто добавите вызов contiguous().

Из [документации pytorch] [1]:

смежный () → Тензор

Returns a contiguous tensor containing the same data as self 

тензор. Если собственный тензор является смежным, эта функция возвращает собственный тензор.

Где contiguousздесь означает не только непрерывность в памяти, но и в том же порядке в памяти, что и порядок индексов: например, выполнение транспонирования не меняет данные в памяти, оно просто меняет карту с индексов на указатели памяти, если вы затем применить, contiguous()он изменит данные в памяти, так что карта из индексов в ячейку памяти будет канонической. [1]: http://pytorch.org/docs/master/tensors.html

tensor.contiguous () создаст копию тензора, и элемент в копии будет сохранен в памяти непрерывным образом. Функция contiguous () обычно требуется, когда мы сначала транспонируем () тензор, а затем меняем его форму (просматриваем). Сначала создадим непрерывный тензор:

aaa = torch.Tensor( [[1,2,3],[4,5,6]] )
print(aaa.stride())
print(aaa.is_contiguous())
#(3,1)
#True

Функция stride () return (3,1) означает, что: при перемещении по первому измерению на каждом шаге (строка за строкой) нам нужно переместить 3 шага в памяти. При перемещении по второму измерению (столбец за столбцом) нам нужно переместить 1 шаг в памяти. Это указывает на то, что элементы в тензоре хранятся непрерывно.

Теперь попробуем применить к тензору функции come:

bbb = aaa.transpose(0,1)
print(bbb.stride())
print(bbb.is_contiguous())

#(1, 3)
#False


ccc = aaa.narrow(1,1,2)   ## equivalent to matrix slicing aaa[:,1:3]
print(ccc.stride())
print(ccc.is_contiguous())

#(3, 1)
#False


ddd = aaa.repeat(2,1)   # The first dimension repeat once, the second dimension repeat twice
print(ddd.stride())
print(ddd.is_contiguous())

#(3, 1)
#True


## expand is different from repeat.
## if a tensor has a shape [d1,d2,1], it can only be expanded using "expand(d1,d2,d3)", which
## means the singleton dimension is repeated d3 times
eee = aaa.unsqueeze(2).expand(2,3,3)
print(eee.stride())
print(eee.is_contiguous())

#(3, 1, 0)
#False


fff = aaa.unsqueeze(2).repeat(1,1,8).view(2,-1,2)
print(fff.stride())
print(fff.is_contiguous())

#(24, 2, 1)
#True

Хорошо, мы можем обнаружить, что транспонирование (), сужение () и тензорное сечение и расширение () сделают сгенерированный тензор несмежным. Интересно, что repeat () и view () не делают его разрозненным. Итак, теперь вопрос: что произойдет, если я использую несмежный тензор?

Ответ заключается в том, что функция view () не может применяться к несмежному тензору. Вероятно, это связано с тем, что view () требует, чтобы тензор сохранялся непрерывно, чтобы он мог быстро изменять форму в памяти. например:

bbb.view(-1,3)

мы получим ошибку:

---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-63-eec5319b0ac5> in <module>()
----> 1 bbb.view(-1,3)

RuntimeError: invalid argument 2: view size is not compatible with input tensor's size and stride (at least one dimension spans across two contiguous subspaces). Call .contiguous() before .view(). at /pytorch/aten/src/TH/generic/THTensor.cpp:203

Чтобы решить эту проблему, просто добавьте contiguous () к несмежному тензору, чтобы создать непрерывную копию, а затем примените view ()

bbb.contiguous().view(-1,3)
#tensor([[1., 4., 2.],
        [5., 3., 6.]])

Как и в предыдущем ответе, contigous () выделяет непрерывные фрагменты памяти , это будет полезно, когда мы передаем тензор в бэкэнд-код c или c ++, где тензоры передаются как указатели.

Принятые ответы были настолько хороши, что я попытался обмануть transpose()эффект функции. Я создал две функции, которые могут проверять файлы samestorage()и файлы contiguous.

def samestorage(x,y):
    if x.storage().data_ptr()==y.storage().data_ptr():
        print("same storage")
    else:
        print("different storage")
def contiguous(y):
    if True==y.is_contiguous():
        print("contiguous")
    else:
        print("non contiguous")

Я проверил и получил такой результат в виде таблицы:

Вы можете просмотреть код проверки ниже, но давайте приведем один пример, когда тензор не является непрерывным . Мы не можем просто вызвать view()этот тензор, он нам может понадобиться reshape()или мы также можем вызвать .contiguous().view().

x = torch.randn(3,2)
y = x.transpose(0, 1)
y.view(6) # RuntimeError: view size is not compatible with input tensor's size and stride (at least one dimension spans across two contiguous subspaces). Use .reshape(...) instead.
  
x = torch.randn(3,2)
y = x.transpose(0, 1)
y.reshape(6)

x = torch.randn(3,2)
y = x.transpose(0, 1)
y.contiguous().view(6)

Также следует отметить, что существуют методы, которые в конце создают непрерывные и несмежные тензоры. Существуют методы, которые могут работать с одним и тем же хранилищем , а некоторые из них перед возвратом flip()создают новое хранилище (читай: клонируйте тензор).

Код проверки:

import torch
x = torch.randn(3,2)
y = x.transpose(0, 1) # flips two axes
print("\ntranspose")
print(x)
print(y)
contiguous(y)
samestorage(x,y)

print("\nnarrow")
x = torch.randn(3,2)
y = x.narrow(0, 1, 2) #dim, start, len  
print(x)
print(y)
contiguous(y)
samestorage(x,y)

print("\npermute")
x = torch.randn(3,2)
y = x.permute(1, 0) # sets the axis order
print(x)
print(y)
contiguous(y)
samestorage(x,y)

print("\nview")
x = torch.randn(3,2)
y=x.view(2,3)
print(x)
print(y)
contiguous(y)
samestorage(x,y)

print("\nreshape")
x = torch.randn(3,2)
y = x.reshape(6,1)
print(x)
print(y)
contiguous(y)
samestorage(x,y)

print("\nflip")
x = torch.randn(3,2)
y = x.flip(0)
print(x)
print(y)
contiguous(y)
samestorage(x,y)

print("\nexpand")
x = torch.randn(3,2)
y = x.expand(2,-1,-1)
print(x)
print(y)
contiguous(y)
samestorage(x,y) 

Насколько я понимаю, это более обобщенный ответ:

Смежный - это термин, используемый для обозначения того, что структура памяти тензора не совпадает с объявленными метаданными или информацией о форме.

На мой взгляд, слово «смежный» - термин, сбивающий с толку / вводящий в заблуждение, поскольку в нормальном контексте оно означает, что память не распределяется по разрозненным блокам (т.е. ее «непрерывная / связная / непрерывная»).

Некоторым операциям может потребоваться это смежное свойство по какой-то причине (скорее всего, эффективность в gpu и т. Д.).

Обратите внимание, что .viewэто еще одна операция, которая может вызвать эту проблему. Посмотрите на следующий код, который я исправил, просто вызвав смежный (вместо типичной проблемы транспонирования, вызывающей это, вот пример, который является причиной, когда RNN не доволен своим вводом):

        # normal lstm([loss, grad_prep, train_err]) = lstm(xn)
        n_learner_params = xn_lstm.size(1)
        (lstmh, lstmc) = hs[0] # previous hx from first (standard) lstm i.e. lstm_hx = (lstmh, lstmc) = hs[0]
        if lstmh.size(1) != xn_lstm.size(1): # only true when prev lstm_hx is equal to decoder/controllers hx
            # make sure that h, c from decoder/controller has the right size to go into the meta-optimizer
            expand_size = torch.Size([1,n_learner_params,self.lstm.hidden_size])
            lstmh, lstmc = lstmh.squeeze(0).expand(expand_size).contiguous(), lstmc.squeeze(0).expand(expand_size).contiguous()
        lstm_out, (lstmh, lstmc) = self.lstm(input=xn_lstm, hx=(lstmh, lstmc))

Ошибка, которую я получал:

RuntimeError: rnn: hx is not contiguous

Источники / Ресурс:

• https://discuss.pytorch.org/t/contigious-vs-non-contigious-tensor/30107/7
• PyTorch - смежные ()